flyinweb's blog

mysql slave延时同步

shanyiwan@live.com(flyinweb) — Thu, 28 Jan 2010 07:28:33 GMT

dlslaved 0.1

(Delayed Slave Daemon for MySQL)

dlslaved

allows delayed replication for MySQL databases.

The

dlslaved

syntax is really simple :

-> dlslaved -h ipAddress -u username -p password -P portNumber

11/06/2007 : initial release

dlslaved

SecondsBehindMaster

STOP

START

dlslaved user's manual

dlslaved source code

/usr/local/mysql

Contact me at rodolphe.jouannet(at)free.fr for support or questions.

根据上述思路，写一shell来实现相同的操作：

#!/bin/bash 
# 
# 监控mysql slave状态，实现slave延时 
# 
INTERVAL="1800" 
#CURPATH=$(pwd) 
CURPATH=/home/adminshell 
AUTH='-uroot -ppassword' 
SLAVE_IO="Slave_IO_Running:" 
SLAVE_SQL="Slave_SQL_Running:" 
SHOW_SLAVE_STATUS="show slave status\G" 
START_SLAVE="start slave" 
STOP_SLAVE="stop slave" 
 
MYSQL="$(which mysql)" 
if [ $? -ge 1 ] 
then 
    MYSQL="/usr/local/mysql/bin/mysql" 
fi 
 
PIDOF="$(which pidof)" 
if [ $? -ge 1 ] 
then 
    PIDOF="/sbin/pidof" 
fi 
 
while : 
do 
    TIMESTAMP_TODAY="$(date +%Y%m%d)" 
    LOGFILE="${CURPATH}/mysql_slave_delay_${TIMESTAMP_TODAY}.log" 
    echo "[`date +%c`] mysqld process check" >> $LOGFILE 
    MYSQLDPID=$($PIDOF mysqld) 
    if [ -z $MYSQLDPID ];then 
        echo "mysqld is not started!" >> $LOGFILE 
    else 
        echo "[`date +%c`] mysqld is running" >> $LOGFILE 
        echo "[`date +%c`] mysql slave status check" >> $LOGFILE 
        SLAVE_IO_STATUS=$($MYSQL $AUTH -Bse "$SHOW_SLAVE_STATUS" | grep $SLAVE_IO | awk '{ print $2 }') 
        SLAVE_SQL_STATUS=$($MYSQL $AUTH -Bse "$SHOW_SLAVE_STATUS" | grep $SLAVE_SQL | awk '{ print $2 }') 
        if [ "$SLAVE_IO_STATUS" = "Yes" -a "$SLAVE_SQL_STATUS" = "Yes" ];then 
            echo "[`date +%c`] mysql slave is running,stop it" >> $LOGFILE 
            $MYSQL $AUTH -Bse "$STOP_SLAVE" 
        else 
            echo "[`date +%c`] mysql slave is not running,start it" >> $LOGFILE 
            $MYSQL $AUTH -Bse "$START_SLAVE" 
        fi 
        echo "[`date +%c`] ****************************************************" >> $LOGFILE 
        sleep ${INTERVAL} 
    fi 
done

Awk学习笔记

shanyiwan@live.com(flyinweb) — Wed, 27 Jan 2010 06:43:55 GMT

Awk学习笔记

整理：Jims of 肥肥世家

<jims.yang@gmail.com>

第一次发布时间:2004年8月6日

1. awk简介

awk 是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。awk的处理文本和数据的方式是这样的，它逐行扫描文件，从第一行到最后一行，寻找匹配的特定模式的行，并在这些行上进行你想要的操作。如果没有指定处理动作，则把匹配的行显示到标准输出 (屏幕)，如果没有指定模式，则所有被操作所指定的行都被处理。awk分别代表其作者姓氏的第一个字母。因为它的作者是三个人，分别是Alfred Aho、Brian Kernighan、Peter Weinberger。gawk是awk的GNU版本，它提供了Bell实验室和GNU的一些扩展。下面介绍的awk是以GUN的gawk为例的，在 linux系统中已把awk链接到gawk，所以下面全部以awk进行介绍。

2. awk命令格式和选项

2.1. awk的语法有两种形式

awk [options] 'script' var=value file(s)
awk [options] -f scriptfile var=value file(s)

2.2. 命令选项

-F fs or --field-separator fs: 指定输入文件折分隔符，fs是一个字符串或者是一个正则表达式，如-F:。
-v var=value or --asign var=value: 赋值一个用户定义变量。
-f scripfile or --file scriptfile: 从脚本文件中读取awk命令。
-mf nnn and -mr nnn: 对 nnn值设置内在限制，-mf选项限制分配给nnn的最大块数目；-mr选项限制记录的最大数目。这两个功能是Bell实验室版awk的扩展功能，在标准 awk中不适用。
-W compact or --compat, -W traditional or --traditional: 在兼容模式下运行 awk。所以gawk的行为和标准的awk完全一样，所有的awk扩展都被忽略。
-W copyleft or --copyleft, -W copyright or --copyright: 打印简短的版权信息。
-W help or --help, -W usage or --usage: 打印全部awk选项和每个选项的简短说明。
-W lint or --lint: 打印不能向传统unix平台移植的结构的警告。
-W lint-old or --lint-old: 打印关于不能向传统unix平台移植的结构的警告。
-W posix: 打开兼容模式。但有以下限制，不识别：\x、函数关键字、func、换码序列以及当fs是一个空格时，将新行作为一个域分隔符；操作符**和**=不能代替^和^=；fflush无效。
-W re-interval or --re-inerval: 允许间隔正则表达式的使用，参考(grep中的Posix字符类)，如括号表达式[[:alpha:]]。
-W source program-text or --source program-text: 使用 program-text作为源代码，可与-f命令混用。
-W version or --version: 打印bug报告信息的版本。

3. 模式和操作

awk脚本是由模式和操作组成的：: pattern {action} 如$ awk '/root/' test，或$ awk '$3 < 100' test。

两者是可选的，如果没有模式，则action应用到全部记录，如果没有action，则输出匹配全部记录。默认情况下，每一个输入行都是一条记录，但用户可通过RS变量指定不同的分隔符进行分隔。

3.1. 模式

模式可以是以下任意一个：

/正则表达式/：使用通配符的扩展集。
关系表达式：可以用下面运算符表中的关系运算符进行操作，可以是字符串或数字的比较，如$2>%1选择第二个字段比第一个字段长的行。
模式匹配表达式：用运算符~(匹配)和~!(不匹配)。
模式，模式：指定一个行的范围。该语法不能包括BEGIN和END模式。
BEGIN：让用户指定在第一条输入记录被处理之前所发生的动作，通常可在这里设置全局变量。
END：让用户在最后一条输入记录被读取之后发生的动作。

3.2. 操作

操作由一人或多个命令、函数、表达式组成，之间由换行符或分号隔开，并位于大括号内。主要有四部份：

变量或数组赋值
输出命令
内置函数
控制流命令

4. awk的环境变量

Table 1. awk的环境变量

变量	描述
$n	当前记录的第n个字段，字段间由 FS分隔。
$0	完整的输入记录。
ARGC	命令行参数的数目。
ARGIND	命令行中当前文件的位置(从0开始算)。
ARGV	包含命令行参数的数组。
CONVFMT	数字转换格式(默认值为%.6g)
ENVIRON	环境变量关联数组。
ERRNO	最后一个系统错误的描述。
FIELDWIDTHS	字段宽度列表(用空格键分隔)。
FILENAME	当前文件名。
FNR	同 NR，但相对于当前文件。
FS	字段分隔符(默认是任何空格)。
IGNORECASE	如果为真，则进行忽略大小写的匹配。
NF	当前记录中的字段数。
NR	当前记录数。
OFMT	数字的输出格式(默认值是%.6g)。
OFS	输出字段分隔符(默认值是一个空格)。
ORS	输出记录分隔符(默认值是一个换行符)。
RLENGTH	由 match函数所匹配的字符串的长度。
RS	记录分隔符(默认是一个换行符)。
RSTART	由 match函数所匹配的字符串的第一个位置。
SUBSEP	数组下标分隔符(默认值是\034)。

5. awk运算符

Table 2. 运算符

运算符	描述
= += -= = /= %= ^= *=	赋值
?:	C条件表达式
\|\|	逻辑或
&&	逻辑与
~ ~!	匹配正则表达式和不匹配正则表达式
< <= > >= != ==	关系运算符
空格	连接
+ -	加，减
* / &	乘，除与求余
+ - !	一元加，减和逻辑非
^ ***	求幂
++ --	增加或减少，作为前缀或后缀
$	字段引用
in	数组成员

6. 记录和域

6.1. 记录

awk 把每一个以换行符结束的行称为一个记录。

记录分隔符：默认的输入和输出的分隔符都是回车，保存在内建变量ORS和RS中。

$0 变量：它指的是整条记录。如$ awk '{print $0}' test将输出test文件中的所有记录。

变量NR：一个计数器，每处理完一条记录，NR的值就增加1。如$ awk '{print NR,$0}' test将输出test文件中所有记录，并在记录前显示记录号。

6.2. 域

记录中每个单词称做“域”，默认情况下以空格或tab分隔。awk可跟踪域的个数，并在内建变量NF中保存该值。如$ awk '{print $1,$3}' test将打印test文件中第一和第三个以空格分开的列(域)。

6.3. 域分隔符

内建变量 FS保存输入域分隔符的值，默认是空格或tab。我们可以通过-F命令行选项修改FS的值。如$ awk -F: '{print $1,$5}' test将打印以冒号为分隔符的第一，第五列的内容。

可以同时使用多个域分隔符，这时应该把分隔符写成放到方括号中，如$awk -F'[:\t]' '{print $1,$3}' test，表示以空格、冒号和tab作为分隔符。

输出域的分隔符默认是一个空格，保存在OFS中。如$ awk -F: '{print $1,$5}' test，$1和$5间的逗号就是OFS的值。

7. gawk专用正则表达式元字符

一般通用的元字符集就不讲了，可参考我的Sed和Grep学习笔记。以下几个是gawk专用的，不适合unix版本的awk。

\Y: 匹配一个单词开头或者末尾的空字符串。
\B: 匹配单词内的空字符串。
\<: 匹配一个单词的开头的空字符串，锚定开始。
\>: 匹配一个单词的末尾的空字符串，锚定末尾。
\w: 匹配一个字母数字组成的单词。
\W: 匹配一个非字母数字组成的单词。
\‘: 匹配字符串开头的一个空字符串。
\': 匹配字符串末尾的一个空字符串。

8. POSIX字符集

可参考我的Grep学习笔记

9. 匹配操作符(~)

用来在记录或者域内匹配正则表达式。如$ awk '$1 ~/^root/' test将显示test文件第一列中以root开头的行。

10. 比较表达式

conditional expression1 ? expression2: expression3，例如：$ awk '{max = {$1 > $3} ? $1: $3: print max}' test。如果第一个域大于第三个域，$1就赋值给max，否则$3就赋值给max。

$ awk '$1 + $2 < 100' test。如果第一和第二个域相加大于100，则打印这些行。

$ awk '$1 > 5 && $2 < 10' test,如果第一个域大于5，并且第二个域小于10，则打印这些行。

11. 范围模板

范围模板匹配从第一个模板的第一次出现到第二个模板的第一次出现之间所有行。如果有一个模板没出现，则匹配到开头或末尾。如$ awk '/root/,/mysql/' test将显示root第一次出现到mysql第一次出现之间的所有行。

12. 一个验证 passwd文件有效性的例子

$ cat /etc/passwd | awk -F: '\ 
NF != 7{\ 
printf("line %d,does not have 7 fields:%s\n",NR,$0)}\ 
$1 !~ /[A-Za-z0-9]/{printf("line %d,non alpha and numeric user id:%d: %s\n,NR,$0)}\ 
$2 == "*" {printf("line %d, no password: %s\n",NR,$0)}'

	cat把结果输出给awk，awk把域之间的分隔符设为冒号。
	如果域的数量(NF)不等于7，就执行下面的程序。
	printf打印字符串"line ?? does not have 7 fields"，并显示该条记录。
	如果第一个域没有包含任何字母和数字，printf打印“no alpha and numeric user id" ，并显示记录数和记录。
	如果第二个域是一个星号，就打印字符串“no passwd”，紧跟着显示记录数和记录本身。

13. 几个实例

$ awk '/^(no|so)/' test-----打印所有以模式no或so开头的行。
$ awk '/^[ns]/{print $1}' test-----如果记录以n或s开头，就打印这个记录。
$ awk '$1 ~/[0-9][0-9]$/(print $1}' test-----如果第一个域以两个数字结束就打印这个记录。
$ awk '$1 == 100 || $2 < 50' test-----如果第一个或等于100或者第二个域小于50，则打印该行。
$ awk '$1 != 10' test-----如果第一个域不等于10就打印该行。
$ awk '/test/{print $1 + 10}' test-----如果记录包含正则表达式test，则第一个域加10并打印出来。
$ awk '{print ($1 > 5 ? "ok "$1: "error"$1)}' test-----如果第一个域大于5则打印问号后面的表达式值，否则打印冒号后面的表达式值。
$ awk '/^root/,/^mysql/' test----打印以正则表达式root开头的记录到以正则表达式mysql开头的记录范围内的所有记录。如果找到一个新的正则表达式root开头的记录，则继续打印直到下一个以正则表达式mysql开头的记录为止，或到文件末尾。

14. awk编程

14.1. 变量

在awk中，变量不需要定义就可以直接使用，变量类型可以是数字或字符串。
赋值格式：Variable = expression，如$ awk '$1 ~/test/{count = $2 + $3; print count}' test,上式的作用是,awk先扫描第一个域，一旦test匹配，就把第二个域的值加上第三个域的值，并把结果赋值给变量count，最后打印出来。
awk 可以在命令行中给变量赋值，然后将这个变量传输给awk脚本。如$ awk -F: -f awkscript month=4 year=2004 test，上式的month和year都是自定义变量，分别被赋值为4和2004。在awk脚本中，这些变量使用起来就象是在脚本中建立的一样。注意，如果参数前面出现test，那么在BEGIN语句中的变量就不能被使用。
域变量也可被赋值和修改，如$ awk '{$2 = 100 + $1; print }' test,上式表示，如果第二个域不存在，awk将计算表达式100加$1的值，并将其赋值给$2，如果第二个域存在，则用表达式的值覆盖$2原来的值。再例如：$ awk '$1 == "root"{$1 ="test";print}' test，如果第一个域的值是“root”，则把它赋值为“test”，注意，字符串一定要用双引号。
内建变量的使用。变量列表在前面已列出，现在举个例子说明一下。$ awk -F: '{IGNORECASE=1; $1 == "MARY"{print NR,$1,$2,$NF}'test，把IGNORECASE设为1代表忽略大小写，打印第一个域是mary的记录数、第一个域、第二个域和最后一个域。

14.2. BEGIN 模块

BEGIN 模块后紧跟着动作块，这个动作块在awk处理任何输入文件之前执行。所以它可以在没有任何输入的情况下进行测试。它通常用来改变内建变量的值，如OFS, RS和FS等，以及打印标题。如：$ awk 'BEGIN{FS=":"; OFS="\t"; ORS="\n\n"}{print $1,$2,$3} test。上式表示，在处理输入文件以前，域分隔符(FS)被设为冒号，输出文件分隔符(OFS)被设置为制表符，输出记录分隔符(ORS)被设置为两个换行符。$ awk 'BEGIN{print "TITLE TEST"}只打印标题。

14.3. END模块

END 不匹配任何的输入文件，但是执行动作块中的所有动作，它在整个输入文件处理完成后被执行。如$ awk 'END{print "The number of records is" NR}' test，上式将打印所有被处理的记录数。

14.4. 重定向和管道

awk 可使用shell的重定向符进行重定向输出，如：$ awk '$1 = 100 {print $1 > "output_file" }' test。上式表示如果第一个域的值等于100，则把它输出到output_file中。也可以用>>来重定向输出，但不清空文件，只做追加操作。
输出重定向需用到getline函数。getline从标准输入、管道或者当前正在处理的文件之外的其他输入文件获得输入。它负责从输入获得下一行的内容，并给NF,NR和FNR等内建变量赋值。如果得到一条记录，getline函数返回1，如果到达文件的末尾就返回0，如果出现错误，例如打开文件失败，就返回-1。如：
$ awk 'BEGIN{ "date" | getline d; print d}' test。执行linux的date命令，并通过管道输出给getline，然后再把输出赋值给自定义变量d，并打印它。
$ awk 'BEGIN{"date" | getline d; split(d,mon); print mon[2]}' test。执行shell的date命令，并通过管道输出给getline，然后getline从管道中读取并将输入赋值给d，split函数把变量d转化成数组mon，然后打印数组mon的第二个元素。
$ awk 'BEGIN{while( "ls" | getline) print}'，命令ls的输出传递给geline作为输入，循环使getline从ls的输出中读取一行，并把它打印到屏幕。这里没有输入文件，因为 BEGIN块在打开输入文件前执行，所以可以忽略输入文件。
$ awk 'BEGIN{printf "What is your name?"; getline name < "/dev/tty" } $1 ~name {print "Found" name on line ", NR "."} END{print "See you," name "."} test。在屏幕上打印”What is your name?",并等待用户应答。当一行输入完毕后，getline函数从终端接收该行输入，并把它储存在自定义变量name中。如果第一个域匹配变量 name的值，print函数就被执行，END块打印See you和name的值。
$ awk 'BEGIN{while (getline < "/etc/passwd" > 0) lc++; print lc}'。awk将逐行读取文件/etc/passwd的内容，在到达文件末尾前，计数器lc一直增加，当到末尾时，打印lc的值。注意，如果文件不存在，getline返回-1，如果到达文件的末尾就返回0，如果读到一行，就返回1，所以命令 while (getline < "/etc/passwd")在文件不存在的情况下将陷入无限循环，因为返回-1表示逻辑真。
可以在awk中打开一个管道，且同一时刻只能有一个管道存在。通过close()可关闭管道。如：$ awk '{print $1, $2 | "sort" }' test END {close("sort")}。awd把print语句的输出通过管道作为linux命令sort的输入,END块执行关闭管道操作。
system 函数可以在awk中执行linux的命令。如：$ awk 'BEGIN{system("clear")'。
fflush 函数用以刷新输出缓冲区，如果没有参数，就刷新标准输出的缓冲区，如果以空字符串为参数，如fflush(""),则刷新所有文件和管道的输出缓冲区。

14.5. 条件语句

awk 中的条件语句是从C语言中借鉴过来的，可控制程序的流程。

14.5.1. if 语句

格式：
        {if (expression){
                   statement; statement; ...
                     }
        }

$ awk '{if ($1 <$2) print $2 "too high"}' test。如果第一个域小于第二个域则打印。

$ awk '{if ($1 < $2) {count++; print "ok"}}' test.如果第一个域小于第二个域，则count加一，并打印ok。

14.5.2. if/else语句，用于双重判断。

格式：
        {if (expression){
                   statement; statement; ...
                       }
        else{
                   statement; statement; ...
                       }
        }

$ awk '{if ($1 > 100) print $1 "bad" ; else print "ok"}' test。如果$1大于100则打印$1 bad,否则打印ok。

$ awk '{if ($1 > 100){ count++; print $1} else {count--; print $2}' test。如果$1大于100，则count加一，并打印$1，否则count减一，并打印$1。

14.5.3. if/else else if语句，用于多重判断。

格式：
        {if (expression){
                    statement; statement; ...
                   }
        else if (expression){
                    statement; statement; ...
                   }
        else if (expression){
                    statement; statement; ...
                   }
        else {
                   statement; statement; ...
             }
        }

14.6. 循环

awk有三种循环:while循环；for循环；special for循环。
$ awk '{ i = 1; while ( i <= NF ) { print NF,$i; i++}}' test。变量的初始值为1，若i小于可等于NF(记录中域的个数),则执行打印语句，且i增加1。直到i的值大于NF.
$ awk '{for (i = 1; i<NF; i++) print NF,$i}' test。作用同上。
breadkcontinue 语句。break用于在满足条件的情况下跳出循环；continue用于在满足条件的情况下忽略后面的语句，直接返回循环的顶端。如：
```
{for ( x=3; x<=NF; x++) 
            if ($x<0){print "Bottomed out!"; break}}
{for ( x=3; x<=NF; x++)
            if ($x==0){print "Get next item"; continue}}
      
```
next语句从输入文件中读取一行，然后从头开始执行awk脚本。如：
```
{if ($1 ~/test/){next}
    else {print}
}
     
```
exit语句用于结束awk程序，但不会略过END块。退出状态为0代表成功，非零值表示出错。

14.7. 数组

awk 中的数组的下标可以是数字和字母，称为关联数组。

14.7.1. 下标与关联数组

用变量作为数组下标。如：$ awk {name[x++]=$2};END{for(i=0;i<NR;i++) print i,name[i]}' test。数组name中的下标是一个自定义变量x，awk初始化x的值为0，在每次使用后增加1。第二个域的值被赋给name数组的各个元素。在END 模块中，for循环被用于循环整个数组，从下标为0的元素开始，打印那些存储在数组中的值。因为下标是关健字，所以它不一定从0开始，可以从任何值开始。
special for循环用于读取关联数组中的元素。格式如下：
```
{for (item in arrayname){
         print arrayname[item]
         }
}
```
$ awk '/^tom/{name[NR]=$1}; END{for(i in name){print name[i]}}' test。打印有值的数组元素。打印的顺序是随机的。
用字符串作为下标。如：count["test"]
用域值作为数组的下标。一种新的for循环方式，for (index_value in array) statement。如:$ awk '{count[$1]++} END{for(name in count) print name,count[name]}' test。该语句将打印$1中字符串出现的次数。它首先以第一个域作数组count的下标，第一个域变化，索引就变化。
delete 函数用于删除数组元素。如：$ awk '{line[x++]=$1} END{for(x in line) delete(line[x])}' test。分配给数组line的是第一个域的值，所有记录处理完成后，special for循环将删除每一个元素。

14.8. awk的内建函数

14.8.1. 字符串函数

sub函数匹配记录中最大、最靠左边的子字符串的正则表达式，并用替换字符串替换这些字符串。如果没有指定目标字符串就默认使用整个记录。替换只发生在第一次匹配的时候。格式如下：
```
            sub (regular expression, substitution string):
            sub (regular expression, substitution string, target string)
```
实例：
```
            $ awk '{ sub(/test/, "mytest"); print }' testfile
            $ awk '{ sub(/test/, "mytest"); $1}; print }' testfile
```
第一个例子在整个记录中匹配，替换只发生在第一次匹配发生的时候。如要在整个文件中进行匹配需要用到gsub
第二个例子在整个记录的第一个域中进行匹配，替换只发生在第一次匹配发生的时候。

gsub函数作用如sub，但它在整个文档中进行匹配。格式如下：

            gsub (regular expression, substitution string)
            gsub (regular expression, substitution string, target string)

实例：

            $ awk '{ gsub(/test/, "mytest"); print }' testfile
            $ awk '{ gsub(/test/, "mytest"), $1 }; print }' testfile

第一个例子在整个文档中匹配test，匹配的都被替换成mytest。

第二个例子在整个文档的第一个域中匹配，所有匹配的都被替换成mytest。

index函数返回子字符串第一次被匹配的位置，偏移量从位置1开始。格式如下：
```
          index(string, substring)
```
实例：
```
            $ awk '{ print index("test", "mytest") }' testfile
```
实例返回test在mytest的位置，结果应该是3。
length函数返回记录的字符数。格式如下：
```
            length( string )
            length
```
实例：
```
            $ awk '{ print length( "test" ) }' 
            $ awk '{ print length }' testfile
```
第一个实例返回test字符串的长度。
第二个实例返回testfile文件中第条记录的字符数。

substr 函数返回从位置1开始的子字符串，如果指定长度超过实际长度，就返回整个字符串。格式如下：

            substr( string, starting position )
            substr( string, starting position, length of string )

实例：

            $ awk '{ print substr( "hello world", 7,11 ) }'

上例截取了world子字符串。

match函数返回在字符串中正则表达式位置的索引，如果找不到指定的正则表达式则返回0。match函数会设置内建变量RSTART为字符串中子字符串的开始位置，RLENGTH为到子字符串末尾的字符个数。 substr可利于这些变量来截取字符串。函数格式如下：
```
            match( string, regular expression )
```
实例：
```
            $ awk '{start=match("this is a test",/[a-z]+$/); print start}'
            $ awk '{start=match("this is a test",/[a-z]+$/); print start, RSTART, RLENGTH }'
```
第一个实例打印以连续小写字符结尾的开始位置，这里是11。
第二个实例还打印RSTART和RLENGTH变量，这里是 11(start)，11(RSTART)，4(RLENGTH)。

toupper和tolower函数可用于字符串大小间的转换，该功能只在gawk中有效。格式如下：

            toupper( string )
            tolower( string )

实例：

            $ awk '{ print toupper("test"), tolower("TEST") }'

split函数可按给定的分隔符把字符串分割为一个数组。如果分隔符没提供，则按当前FS值进行分割。格式如下：
```
            split( string, array, field separator )
            split( string, array )
```
实例：
```
            $ awk '{ split( "20:18:00", time, ":" ); print time[2] }'
```
上例把时间按冒号分割到time数组内，并显示第二个数组元素18。

14.8.2. 时间函数

systime函数返回从1970年1月1日开始到当前时间(不计闰年)的整秒数。格式如下：
```
            systime()
```
实例：
```
            $ awk '{ now = systime(); print now }'
```

strftime函数使用C库中的strftime函数格式化时间。格式如下：

            systime( [format specification][,timestamp] )

Table 3. 日期和时间格式说明符

格式	描述
%a	星期几的缩写(Sun)
%A	星期几的完整写法(Sunday)
%b	月名的缩写(Oct)
%B	月名的完整写法(October)
%c	本地日期和时间
%d	十进制日期
%D	日期 08/20/99
%e	日期，如果只有一位会补上一个空格
%H	用十进制表示24小时格式的小时
%I	用十进制表示12小时格式的小时
%j	从1月1日起一年中的第几天
%m	十进制表示的月份
%M	十进制表示的分钟
%p	12 小时表示法(AM/PM)
%S	十进制表示的秒
%U	十进制表示的一年中的第几个星期(星期天作为一个星期的开始)
%w	十进制表示的星期几(星期天是 0)
%W	十进制表示的一年中的第几个星期(星期一作为一个星期的开始)
%x	重新设置本地日期(08/20/99)
%X	重新设置本地时间(12：00：00)
%y	两位数字表示的年(99)
%Y	当前月份
%Z	时区(PDT)
%%	百分号(%)

实例：

            $ awk '{ now=strftime( "%D", systime() ); print now }'
            $ awk '{ now=strftime("%m/%d/%y"); print now }'

14.8.3. 内建数学函数

Table 4.

函数名称	返回值
atan2(x,y)	y,x范围内的余切
cos(x)	余弦函数
exp(x)	求幂
int(x)	取整
log(x)	自然对数
rand()	随机数
sin(x)	正弦
sqrt(x)	平方根
srand(x)	x是rand()函数的种子
int(x)	取整，过程没有舍入
rand()	产生一个大于等于0而小于1的随机数

14.8.4. 自定义函数

在 awk中还可自定义函数，格式如下：

        function name ( parameter, parameter, parameter, ... ) {
                        statements
                        return expression                  # the return statement and expression are optional
        }

15. How-to

如何把一行竖排的数据转换成横排？
awk '{printf("%s,",$1)}' filename

统计文件中字符出现次数

shanyiwan@live.com(flyinweb) — Wed, 27 Jan 2010 06:20:16 GMT

统计文件中字符出现次数假设文件(test.txt)内容如下：
1
1
2
2
3
3
4
要求结果显示：
2 1
2 2
2 3
1 4
说明：第一列为字符串出现的频率，第二列为字符串内容，

方法一:

uniq -c test.txt

效果：

2 1
2 2
2 3
1 4

注意，如果上述文件中，字符串没有sort的，则可以先sort

sort test.txt | uniq -c | sort -nr

方法二:

awk '{p[$1] += 1}END{for(a in p) print p[a],"\t",a}' file

效果：

2 1
2 2
2 3
1 4

按出现次数大小排序

awk '{p[$1] += 1}END{for(a in p) print p[a],"\t",a}' test.txt|sort -nr

Informix主要系统表的结构及相关字段的含义

shanyiwan@live.com(flyinweb) — Tue, 26 Jan 2010 02:11:02 GMT

内容提要:
介绍Informix系统表的结构及相关字段的含义

说明:
一、实例信息
*sysconfig ————>; onconfig文件
*sysprofile ————>; 服务器统计信息
*syslog ————>; 逻辑日志
*sysvpprof ————>; 虚拟处理器
create table "sysmaster".sysconfig {服务器配置参数}
(
cf_id integer, {唯一数字标志符 }
cf_name char(18) , {onconfig参数名 }
cf_flags integer, {标志，0=在视图中 }
cf_original char(256), {启动时在onconfig中的值 }
cf_effective char(256), {实际使用的值 }
cf_default char(256) {onconfig文件中不指定时默认使用的值 }
);
grant select on sysconfig to public;

create table "sysmaster".sysprofile {服务器概貌信息}
(
name char(13), {概貌元素名 }
value integer {当前值 }
);
grant select on sysprofile to public;

create table "sysmaster".syslogs {逻辑日志信息}
(
number smallint, {日志文件号 }
uniqid integer, {日志文件唯一ID }
size integer, {日志文件页 }
used integer, {日志文件使用的页 }
is_used integer, {1为已用，0为未用 }
is_current integer, {1为当前 }
is_backed_up integer, {1为备份 }
is_new integer, {1为新 }
is_archived integer, {1为存档 }
is_temp integer, {1为临时 }
flags smallint {日志文件标志 }
);
grant select on syslogs to public;

create table "sysmaster".sysvpprof {虚处理器信息与统计}
(
vpid integer, {虚拟处理器 }
class char(50),{虚拟处理器类名(cpu, adm, lio, pio等)}
usercpu float, {用户时间unix秒数 }
syscpu float {系统时间unix秒数 }
);
grant select on sysvpprof to public;

二、dbspace与块信息
*sysdbspaces ————>; dbspace
*syschunks ————>; 块
*syschkio ————>; 块I/O
*syschfree ————>; 块自由空间注：syschfree是个不支持的表

create table "sysmaster".sysdbspaces {dbspace配置}
(
dbsnum smallint, {dbspace号 }
name char(18), {dbspace名 }
owner char(8), {dbspace拥有者 }
fchunk smallint, {dbspace第一块 }
nchunks smallint, {dbspace块数 }
is_mirrored integer, {dbspace是否镜像 1=YES，0=NO}
is_blobspace integer, {dbspace是否大对象空间 }
is_temp integer, {dbspace是否临时，1=YES，0=NO }
flags smallint {dbspace标志 }
);
grant select on sysdbspaces to public;

create table "sysmaster".syschunks {chunk配置}
(
chknum smallint, {chunk号 }
dbsnum smallint, {dbspace号 }
nxchknum smallint, {dbspace中下一个块号 }
chksize integer, {chunk中的页 }
offset integer, {设备页偏移量 }
nfree integer, {块中未用页数 }
is_offline integer, {chunk是否脱机，1=YES，0=NO}
is_recovering integer, {chunk是否恢复，1=YES，0=NO}
is_blobchunk integer, {chunk是否blobchunk，1=YES，0=NO}
is_inconsistent integer, {chunk是否不一致，1=YES，0=NO }
flags smallint, {由bitbal转换的块标志 }
fname char(128),{设备路径名 }
mfname char(128),{镜像设备路径名 }
moffset integer, {镜像设备偏移量 }
mis_offline integer, {镜像是否脱机，1=YES，0=NO }
mis_recovering integer, {镜像是否恢复，1=YES，0=NO }
mflags smallint {镜像块标志 }
);
grant select on syschunks to public;

create table "sysmaster".syschfree {显示块中的未用空间块}
(
chknum integer, { chunk number 块号 }
extnum integer, { extent number in chunk 块区域号 }
start integer, { physical addr of start 开始物理地址 }
leng integer { length of extent 区域长度 }
);
create unique index syschfreeidx on syschfree (chknum, extnum);
revoke all on syschfree from public;
grant select on syschfree to public;

create table "sysmaster".syschkio {块设备I/O统计信息}
(
chunknum smallint, {块号 }
reads integer, {读操作数 }
pagesread integer, {读页数 }
writes integer, {写操作数 }
pageswritten integer, {写页数 }
mreads integer, {镜像读操作数 }
mpagesread integer, {镜像读页数 }
mwrites integer, {镜像写操作数 }
mpageswritten integer {镜像写页数 }
);
grant select on syschkio to public;

三、数据库与表信息
*sysdatabases ————>; 数据库
*systabnames ————>; 表
*sysextents ————>; 表区域
*sysptprof ————>; 表I/O

create table "sysmaster".sysdatabase {实例中所有的数据库信息}
(
name char(18), {数据库名 }
partnum integer, {systables表ID }
owner char(8), {生成者用户名 }
created integer, {生成日期 }
is_logging integer, {无缓冲日志，1=YES，0=NO }
is_buff_log integer, {缓冲日志，1=YES，0=NO }
is_ansi integer, {ANSI方式数据库1=YES，0=NO }
is_nls integer, {NLS支持，1=YES，0=NO }
flags smallint {指示日志的标志 }
);
grant select on sysdatabase to public;

create table "sysmaster".systabnames {实例中的所有表}
(
partnum integer, { table id for table 表号 }
dbsname char(18), { database name 数据库名}
owner char(8), { table owner 表拥有者 }
tabname char(18), { table name 表名 }
collate char(32) { collation assoc with database 与GLS的相关性 }
);
create unique index systabs_pnix on systabnames(partnum);
revoke all on systabnames from public;
grant select on systabnames to public;

create table "sysmaster".sysextents {实例中的表和每个区域}
(
dbsname char(18), {数据库名 }
tabname char(18), {表名 }
start integer, {这个区域的物理地址 }
size integer {这个区域的长度(页数) }
);
grant select on sysextents to public;

create table "sysmaster".sysptnext {区域的信息}
(
pe_partnum integer, { partnum for this partition 这个区域的编号 }
pe_extnum smallint, { extent number 区域号 }
pe_phys integer, { physical addr for this extent 这个区域的物理地址 }
pe_size integer, { size of this extent 这个区域的长度(页数) }
pe_log integer { logical page for start 开始逻辑页 }
);
create unique index sysptnextidx on sysptnext (pe_partnum, pe_extnum);
revoke all on sysptnext from public;
grant select on sysptnext to public;

create table "sysmaster".sysptprof {表I/O概貌}
(
dbsname char(18), {数据库名}
tabname char(18), {表名 }
partnum integer, {表编号 }
lockreqs integer, {锁请求 }
lockwts integer, {锁等待 }
deadlks integer, {死锁 }
lktouts integer, {锁超时 }
isreads integer, {读 }
iswrites integer, {写入 }
isrewrites integer, {改写 }
isdeletes integer, {删除 }
bufreads integer, {缓冲区读}
bufwrites integer, {行冲区写}
seqscans integer, {顺序扫描}
pagreads integer, {磁盘读 }
pagwrites integer {磁盘写 }
);
grant select on sysptprof to public;

四、用户对话信息
*syssessions ————————>; 对话数据
*syssesprof ————————>; 用户统计信息
*syslocks ————————>; 用户锁
*syseswts ————————>; 等待时间

create table "sysmaster".syssessions {用户对话与连接信息}
(
sid integer, {对话号 }
username char(8), {用户名 }
uid smallint,{用户unix号 }
pid integer, {用户进程号 }
hostname char(16),{主机名 }
tty char(16),{tty端口 }
connected integer, {用户连接时间 }
feprogram char(16),{程序名 }
pooladdr integer, {专有对话池指针 }
is_wlatch integer, {标志1=YES，0=NO，等待锁存 }
is_wlock integer, {标志1=YES，0=NO，等待锁 }
is_wbuff integer, {标志1=YES，0=NO，等待缓冲区 }
is_wckpt integer, {标志1=YES，0=NO，等待校验点 }
is_wlogbuf integer, {标志1=YES，0=NO，等待日志缓冲区}
is_wtrans integer, {标志1=YES，0=NO，等待事务 }
is_monitor integer, {标志1=YES，0=NO，监视进程 }
is_incrit integer, {标志1=YES，0=NO，在关键段中 }
state integer {标志 }
);
grant select on syssessions to public;

create table "sysmaster".syssesprof {用户对话性能统计}
(
sid integer, {对话号 }
lockreqs decimal(16,0), {请求的锁 }
locksheld decimal(16,0), {锁保持 }
lockwts decimal(16,0), {锁等待 }
deadlks decimal(16,0), {发现的死锁 }
lktouts decimal(16,0), {死锁超时 }
logrecs decimal(16,0), {逻辑日志记录写入 }
isreads decimal(16,0), {读 }
iswrites decimal(16,0), {写 }
isrewrites decimal(16,0), {改写 }
isdeletes decimal(16,0), {删除 }
iscommits decimal(16,0), {提交 }
isrollbacks decimal(16,0), {撤销 }
longtxs decimal(16,0), {长事务 }
bufreads decimal(16,0), {缓冲区读 }
bufwrites decimal(16,0), {缓冲区写 }
seqscans decimal(16,0), {顺序扫描 }
pagreads decimal(16,0), {页读 }
pagwrites decimal(16,0), {页写 }
total_sorts decimal(16,0), {总排序 }
dsksorts decimal(16,0), {磁盘排序 }
max_sortdiskspace decimal(16,0),{排序使用的最大空间 }
logspused decimal(16,0), {当前使用的日志字节 }
maxlogsp decimal(16,0) {逻辑日志使用的最大空间}
);
grant select on syssesprof to public;

create table "sysmaster".syslocks {服务器上的锁活动}
(
dbsname char(18), {数据库 }
tabname char(18), {表名 }
rowidlk integer, {索引关键字锁的行号 }
keynum smallint, {索引关键字锁的关键字号}
type integer, {锁拥有者对话ID }
owner integer, {第一个等待者对话ID }
waiter char(4) {锁类型 }
);
grant select on syslocks to public;
{*******************************************************
注：锁类型包括
*B ——————>;byte lock(字节锁)
*IS ——————>;intent shared lock(意图共享锁)
*S ——————>;shared lock(共享锁)
*XS ——————>;repeatable read shared key(可重复读共享锁)
*U ——————>;update lock(更新锁)
*IX ——————>;intent exclusive lock(意图独占锁)
*SIX ——————>;shared intent exclusive(共享意图独占锁)
*X ——————>;exclusive lock(独占锁)
*XR ——————>;repreatable read exclusive(可重复读独占锁)

基本说来，这些锁类型是三种锁的组合：共享锁(S)、独占锁(X)、更新锁(U)。共享锁使其他用户也能读数据，但不能改变数据。独占锁不让其他用户共享数据。
更新锁在更新数据时不让其他用户改变数据。

IDS中可以锁定的对象包括：
*数据库 ——————>;每个用户打开数据库时即对数据库采用共享锁，防止别人删除正在使用的数据。这个操作显示为sysmaster数据库和sysdatabase表中的锁，rowid指向包含数据库名的记录。
*表 ——————>;表锁显示为表上的锁，rowid为0，keynum为0。
*页 ——————>;页锁显示为rowid以00结尾，即页中的所有行均锁定。
*行 ——————>;行锁显示实际rowid(不以00结尾)。
*键 ——————>;键锁显示为keynum如果行的索引需要更新，则锁在该行的索引。
********************************************************}

create table "sysmaster".sysseswts {对象等待状态与时间}
(
sid integer, {对话ID }
reason char(50), {等待原因说明 }
numwaits integer, {这个原因的等待数 }
cumtime float, {这个原因的等待累计时间}
maxtime integer {这个原因的等待最长时间}
);
grant select on sysseswts to public;

create table "sysmaster".systrans {用户事务}
(
tx_id integer,{事务表指针 }
tx_logbeg integer,{事务开始的逻辑日志号 }
tx_loguniq integer {事务中使用的当前逻辑日志号}
);
grant select on systrans to public;

create table "sysmaster".syssqexpalin {用户查询}
(
sqx_sessionid integer, {SQL语句的对话ID，匹配onstat -u 输出 }
sqx_bufreads integer, {SQL语句完成的缓冲区读次数}
sqx_pagereads integer, {SQL语句完成的页面读次数}
sqx_totsorts integer, {SQL语句完成的排序次数}
sqx_estcost integer, {这个查询的估计成本，应与SET EXPLAIN的输出相同。注：这个成本有时偏高，但可以作为寻找坏查询的参考}
sqx_estrows integer, {检查这个查询返回的行，应与SET EXPALIN的输出相同}
sqx_seqscan smallint,{查询是顺序表格扫描时返回1，通常表示有问题}
sqx_srtscan smallint,{查询是排序扫描时返回1}
sqx_autoindex smallint,{查询是表格自动索引时返回1}
sqx_mrgjoin smallint,{查询是合并连接时返回1}
sqx_dynhashjoin smallint,{查询是动态散列连接时返回1 }
sqx_sqlstatement char(32000){SQL语句文本 }
);
grant select on syssqexplain to public;

参考资料:Informix数据库管理员手册

informx技术支持库

shanyiwan@live.com(flyinweb) — Tue, 26 Jan 2010 01:59:10 GMT

informx技术支持库

标题

	如何清理hung住的分布式事务	2010-01-08
	IDS 11.50版本中的限制连接数新特性介绍	2010-01-08
	如何找到数据库的哪些用户具有DBA权限？	2010-01-08
	为什么数据库的逻辑日志不能够动态增加？	2010-01-08
	如何让informix数据库再次进入到恢复模式，来完成之前失败的数据备份恢复操作？	2010-01-08
	应用程序变更引起的KAIO: out of OS resources	2010-01-08
	使用onbar备份做表级恢复时 archeck core dump	2010-01-08
	如何正确删除informix的共享内存段	2010-01-08
	如何判断不同类型的长事务	2010-01-08
	Onbar备份恢复的辅助工具 onsmsync	2010-01-08
	当遇到日志满的情况时应该收集的信息	2010-01-08
	异步方式下 HDR备机对主机的性能影响	2010-01-08
	获取当前informix产品或库文件版本几种方法	2010-01-08
	如何获取最近的SQL执行时生成的serial值和所处理的记录数	2010-01-08
	查询优化器介绍	2010-01-08
	如何查找那个session使用了过多的临时表空间	2010-01-08
	使用fragment提高权限管理的粒度	2010-01-08
	使用PDQ提高建立index的效率	2010-01-08
	Informix 一个锁占用多少内存空间	2010-01-08
	如何监控Informix数据库长事务回滚进度	2010-01-08
	全局事务事务导致数据库阻塞的解决方法	2010-01-08
	使用SQL trace分析SQL语句	2010-01-08
	Informix CLI 与 ODBC	2010-01-08
	Onstat 　g ntt 打印出网络用户时间	2010-01-08
	Onstat 　u输出	2010-01-08
	时间戳	2010-01-08
	使用onmode 　F 释放共享内存	2010-01-08
	是否可以在HDR secondary上执行oncheck检查？	2010-01-08
	IDS通信文件.info.servicename	2009-08-17
	audit初步使用	2009-08-17

标题

	如何查找表中存在的重复记录	2009-08-17
	使用硬件复制技术备份Informix时，需要步骤	2009-08-17
	IDS 11.50.xC5 '合并'新功能介绍	2009-08-17
	ISA之远程信息收集	2009-08-17
	如何使用setLogWriter打开Informix JDBC driver的跟踪日志	2009-08-17
	如何监控数据库的回滚进程	2009-08-17
	如何使用新的方法来打开SQLIDEBUG	2009-08-17
	收集数据之客户端服务器连接-客户端连接失败	2009-08-17
	对于informix产品问题需要收集的一般性信息	2009-08-17
	IDS11.50.xC5 “延迟处理”新功能介绍	2009-08-17
	IDS11.50.xC5“分级查询”新功能介绍	2009-08-17
	无标题	2009-08-17
	备份信息是如何存储在保留页当中的	2009-08-17
	在线日志中关于逻辑日志的警告信息及预防措施	2009-08-17
	使用SQL创建默认的Low/medium/high update statistics 语句	2009-08-17
	如何获得含有远程表的查询计划	2009-08-17
	升级到JDBC3.50后，插入数据报“-79783 Encoding or code set not supported”的错误信息	2009-08-17
	JDBC3.50 在WAS 6.0版本上不能正确显示中文的问题	2009-08-17
	HDR环境使用sequence对象可出现重复值	2009-08-17
	IDS通信文件.info.servicename	2009-08-17
	audit初步使用	2009-08-17
	Informix 11.5 新特性介绍: 第 1 部分	2009-08-17
	Informix 11.5 新特性介绍: 第 2 部分	2009-08-17
	Informix 11.5 新特性介绍: 第 3 部分	2009-08-17
	Informix 11.5 新特性介绍: 第 4 部分	2009-08-17
	如何卸载Informix产品	2009-08-17
	HDR数据复制过程原理	2009-08-17
	为什么HDR Secondary会丢失已经提交的交易	2009-08-17
	Informix 11.5 新特性介绍: 第 5 部分	2009-08-17
	Informix 11.5 新特性介绍: 第 6 部分	2009-08-17

标题

	升级到JDBC3.50后，插入数据报“-79783 Encoding or code set not supported”的错误信息	2009-08-17
	JDBC3.50 在WAS 6.0版本上不能正确显示中文的问题	2009-08-17
	HDR环境使用sequence对象可出现重复值	2009-08-17
	如何删除共享内存段	2009-05-26
	Server Hung in Blocked Checkpoint	2009-05-26
	Bufwait问题分析	2009-05-26
	应用插入数据报 -271 错误分析	2009-05-26
	如何重新安装scheduler API	2009-05-26
	Informix配置参数EXTSHMADD用途简述	2009-05-26
	update statistics的功能与作用介绍	2009-05-21
	避免长事务的方法	2009-05-21
	死锁的预防	2009-05-21
	RA_PAGES 和 RA_THRESHOLD 的配置与调整	2009-05-21
	-881 Resulting string length from TRIM exceeds the limit	2009-05-21
	怎样开启IDS的大chunk支持	2009-05-20
	Onstat工具的加强与更新(2)	2009-05-20
	KAIO OUT OF RESOURCE	2009-05-20
	怎样重构或者迁移IDS 11版本中的sysadmin系统数据库。	2009-04-10
	收集数据：informix家族产品必读	2009-04-10
	解决数据库系统中存在的半个汉字问题	2009-04-10
	实时监控数据库表的数据插入情况	2009-04-10
	如何下载informix产品或补丁版本	2009-04-10
	INFORMIX锁机制及如何分析其锁冲突（第一部分）	2009-04-03
	INFORMIX锁机制及如何分析其锁冲突（第二部分）	2009-04-03
	理解Informix Dynamic Server index B-Tree scanner	2009-04-03
	[Informix数据库服务器数据访问方式分析及优化方法之二	2009-04-03
	Informix主要系统表的结构及相关字段的含义	2009-04-01
	HP 平台上如何判断是否达到文件描述符使用上限	2009-04-01
	Informix数据库对UTF8字符集的支持	2009-04-01
	如何除去表中数据回车符的方法	2009-04-01

标题

	Errors -25573 and oserr = 233 or Network driver cannot accept a connection on the port	2009-04-01
	HP 平台上如何判断是否达到文件描述符使用上限	2009-04-01
	Informix XPS 安装配置和基本使用	2009-04-01
	informix 虚拟处理器	2009-04-01
	有关informix BTS defect问题导致IDS数据库系统运行故障的说明。	2009-02-17
	informix中理解统计更新	2009-02-17
	informix客户端连接数据库,报密码错误	2009-02-17
	Informix数据库服务器数据访问方式分析及优化方法第一部分	2009-02-17
	使用onlog查找、验证历史信息	2009-02-13
	如何kill分布式事务类型的长事务	2009-02-13
	Informix与client SDK安装顺序，及其匹配原则	2009-02-13
	IDS 7版与IDS 9版HDR的差异	2009-02-13
	如何估算长事务回滚的时间	2009-02-09

浅谈Java中的垃圾回收机制

shanyiwan@live.com(flyinweb) — Fri, 22 Jan 2010 08:37:54 GMT

1.垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。
事实上，除了释放没用的对象，垃圾收集也可以清除内存记录碎片。
2.但是任何一种垃圾收集算法一般要做2件基本的事情：（1）发现无用信息对象；（2）回收被无用对象占用的内存空间，使该空间可被程序再次使用。
如何来发现无用的信息对象呢？如何来回收呢？
3.大多数垃圾回收算法使用了根集(root set)这个概念；所谓根集就量正在执行的Java程序可以访问的引用变量的集合(包括局部变量、参数、类变量)，程序可以使用引用变量访问对象的属性和调用对象的方法。垃圾收集首选需要确定从根开始哪些是可达的和哪些是不可达的，从根集可达的对象都是活动对象，它们不能作为垃圾被回收，这也包括从根集间接可达的对象。而根集通过任意路径不可达的对象符合垃圾收集的条件，应该被回收。

1、引用计数法(Reference Counting Collector)

　　引用计数法是唯一没有使用根集的垃圾回收的法，该算法使用引用计数器来区分存活对象和不再使用的对象。一般来说，堆中的每个对象对应一个引用计数器。当每一次创建一个对象(new一个对象)并赋给一个变量时，引用计数器置为 1。当对象被赋给任意变量时，引用计数器每次加1当对象出了作用域后(该对象丢弃不再使用，请问是什么知道这个对象是不要用了呢？)，引用计数器减1，一旦引用计数器为0，对象就满足了垃圾收集的条件。

2、tracing算法(Tracing Collector)

　　tracing算法是为了解决引用计数法的问题而提出，它使用了根集的概念。基于tracing算法的垃圾收集器从根集开始扫描，识别出哪些对象可达，哪些对象不可达，并用某种方式标记可达对象，例如对每个可达对象设置一个或多个位。在扫描识别过程中，基于tracing算法的垃圾收集也称为标记和清除(mark-and-sweep)垃圾收集器.

3、compacting算法(Compacting Collector)

　　为了解决堆碎片问题，基于tracing的垃圾回收吸收了Compacting算法的思想，在清除的过程中，算法将所有的对象移到堆的一端，堆的另一端就变成了一个相邻的空闲内存区，收集器会对它移动的所有对象的所有引用进行更新，使得这些引用在新的位置能识别原来的对象。在基于Compacting算法的收集器的实现中，一般增加句柄和句柄表。　　

分代垃圾回收详述

如上图所示，为Java堆中的各代分布。

Young（年轻代）
年轻代分三个区。一个Eden区，两个Survivor区。大部分对象在 Eden区中生成。当Eden区满时，还存活的对象将被复制到Survivor区（两个中的一个），当这个Survivor区满时，此区的存活对象将被复制到另外一个Survivor区，当这个Survivor去也满了的时候，从第一个Survivor区复制过来的并且此时还存活的对象，将被复制“年老区 (Tenured)”。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来对象，和从前一个Survivor复制过来的对象，而复制到年老区的只有从第一个Survivor去过来的对象。而且，Survivor区总有一个是空的。
Tenured（年老代）
年老代存放从年轻代存活的对象。一般来说年老代存放的都是生命期较长的对象。
Perm（持久代）
用于存放静态文件，如今 Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类。持久代大小通过-XX:MaxPermSize=<N>进行设置。

GC类型
GC有两种类型：Scavenge GC和Full GC。

Scavenge GC
一般情况下，当新对象生成，并且在Eden申请空间失败时，就好触发Scavenge GC，堆Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。
Full GC
对整个堆进行整理，包括Young、Tenured和Perm。Full GC比Scavenge GC要慢，因此应该尽可能减少Full GC。有如下原因可能导致Full GC：
- Tenured被写满
- Perm域被写满
- System.gc()被显示调用
- 上一次GC之后Heap的各域分配策略动态变化

目前的收集器主要有三种：串行收集器、并行收集器、并发收集器。

串行收集器

使用单线程处理所有垃圾回收工作，因为无需多线程交互，所以效率比较高。但是，也无法使用多处理器的优势，所以此收集器适合单处理器机器。当然，此收集器也可以用在小数据量（100M左右）情况下的多处理器机器上。可以使用-XX:+UseSerialGC打开。
并行收集器
1. 对年轻代进行并行垃圾回收，因此可以减少垃圾回收时间。一般在多线程多处理器机器上使用。使用-XX:+UseParallelGC.打开。并行收集器在J2SE5.0第六6更新上引入，在Java SE6.0中进行了增强--可以堆年老代进行并行收集。如果年老代不使用并发收集的话，是使用单线程进行垃圾回收，因此会制约扩展能力。使用-XX:+UseParallelOldGC打开。
2. 使用-XX:ParallelGCThreads=<N>设置并行垃圾回收的线程数。此值可以设置与机器处理器数量相等。
3. 此收集器可以进行如下配置：
  - 最大垃圾回收暂停:指定垃圾回收时的最长暂停时间，通过-XX:MaxGCPauseMillis=<N>指定。<N>为毫秒.如果指定了此值的话，堆大小和垃圾回收相关参数会进行调整以达到指定值。设定此值可能会减少应用的吞吐量。
  - 吞吐量:吞吐量为垃圾回收时间与非垃圾回收时间的比值，通过-XX:GCTimeRatio=<N>来设定，公式为1/（1+N）。例如，-XX:GCTimeRatio=19时，表示5%的时间用于垃圾回收。默认情况为99，即1%的时间用于垃圾回收。
并发收集器
可以保证大部分工作都并发进行（应用不停止），垃圾回收只暂停很少的时间，此收集器适合对响应时间要求比较高的中、大规模应用。使用-XX:+UseConcMarkSweepGC打开。
1. 并发收集器主要减少年老代的暂停时间，他在应用不停止的情况下使用独立的垃圾回收线程，跟踪可达对象。在每个年老代垃圾回收周期中，在收集初期并发收集器会对整个应用进行简短的暂停，在收集中还会再暂停一次。第二次暂停会比第一次稍长，在此过程中多个线程同时进行垃圾回收工作。
2. 并发收集器使用处理器换来短暂的停顿时间。在一个N个处理器的系统上，并发收集部分使用K/N个可用处理器进行回收，一般情况下1<=K<=N/4。
3. 在只有一个处理器的主机上使用并发收集器，设置为incremental mode模式也可获得较短的停顿时间。
4. 浮动垃圾：由于在应用运行的同时进行垃圾回收，所以有些垃圾可能在垃圾回收进行完成时产生，这样就造成了“Floating Garbage”，这些垃圾需要在下次垃圾回收周期时才能回收掉。所以，并发收集器一般需要20%的预留空间用于这些浮动垃圾。
5. Concurrent Mode Failure：并发收集器在应用运行时进行收集，所以需要保证堆在垃圾回收的这段时间有足够的空间供程序使用，否则，垃圾回收还未完成，堆空间先满了。这种情况下将会发生“并发模式失败”，此时整个应用将会暂停，进行垃圾回收。
6. 启动并发收集器：因为并发收集在应用运行时进行收集，所以必须保证收集完成之前有足够的内存空间供程序使用，否则会出现“Concurrent Mode Failure”。通过设置-XX:CMSInitiatingOccupancyFraction=<N>指定还有多少剩余堆时开始执行并发收集
小结
- 串行处理器：
  --适用情况：数据量比较小（100M左右）；单处理器下并且对响应时间无要求的应用。
  --缺点：只能用于小型应用
- 并行处理器：
  --适用情况：“对吞吐量有高要求”，多CPU、对应用响应时间无要求的中、大型应用。举例：后台处理、科学计算。
  --缺点：应用响应时间可能较长
- 并发处理器：
  --适用情况：“对响应时间有高要求”，多CPU、对应用响应时间有较高要求的中、大型应用。举例：Web服务器/应用服务器、电信交换、集成开发环境。

堆大小设置
JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。
典型设置：

java -Xmx3550m -Xms3550m -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxPermSize=16m -XX:MaxTenuringThreshold=0
说明：
-Xmx3550m：设置JVM最大可用内存为3550M。
-Xms3550m：设置JVM促使内存为3550m。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn2g：设置年轻代大小为2G。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。
-Xss128k：设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。
-XX:NewRatio=4:设置年轻代（包括Eden和两个Survivor区）与年老代的比值（除去持久代）。设置为4，则年轻代与年老代所占比值为1：4，年轻代占整个堆栈的1/5

java -Xmx3550m -Xms3550m -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxPermSize=16m -XX:MaxTenuringThreshold=0 
说明：
-XX:NewRatio=4:设置年轻代（包括Eden和两个Survivor区）与年老代的比值（除去持久代）。设置为4，则年轻代与年老代所占比值为1：4，年轻代占整个堆栈的1/5  
-XX:SurvivorRatio=4：设置年轻代中Eden区与Survivor区的大小比值。设置为4，则两个Survivor区与一个Eden区的比值为2:4，一个Survivor区占整个年轻代的1/6  
-XX:MaxPermSize=16m:设置持久代大小为16m。  
-XX:MaxTenuringThreshold=0：设置垃圾最大年龄。如果设置为0的话，则年轻代对象不经过Survivor区，直接进入年老代。对于年老代比较多的应用，可以提高效率。如果将此值设置为一个较大值，则年轻代对象会在Survivor区进行多次复制，这样可以增加对象再年轻代的存活时间，增加在年轻代即被回收的概论。

常见配置汇总

堆设置
- -Xms:初始堆大小
- -Xmx:最大堆大小
- -XX:NewSize=n:设置年轻代大小
- -XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
- -XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
- -XX:MaxPermSize=n:设置持久代大小

收集器设置
- -XX:+UseSerialGC:设置串行收集器
- -XX:+UseParallelGC:设置并行收集器
- -XX:+UseParalledlOldGC:设置并行年老代收集器
- -XX:+UseConcMarkSweepGC:设置并发收集器

垃圾回收统计信息
- -XX:+PrintGC
- -XX:+PrintGCDetails
- -XX:+PrintGCTimeStamps
- -Xloggc:filename

并行收集器设置
- -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
- -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
- -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)

并发收集器设置

-XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
-XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数

php中session过期时间设置

shanyiwan@live.com(flyinweb) — Fri, 22 Jan 2010 02:34:52 GMT

php中session过期时间设置：修改PHP配置文件中的session.gc_maxlifetime。

概述：每一次php请求，会有1/100的概率（默认值）触发“session回收”。如果“session回收”发生，那就会检查/tmp/sess_*的文件，如果最后的修改时间到现在超过了1440秒（gc_maxlifetime的值），就将其删除，意味着这些session过期失效。

1. session在Server端（一般是Apache with PHP module）如何存在的？

默认的，php会将session保存在/tmp目录下，文件名为这个样子：sess_01aab840166fd1dc253e3b4a3f0b8381。每一个文件对应了一个session（会话）。

more /tmp/sess_01aab840166fd1dc253e3b4a3f0b8381
username|s:9:”jiangfeng”;admin|s:1:”0″;
#变量名|类型:长度:值

删除这里的session文件，就表示对应的session失效了。

2. session在client端（一般是浏览器）如何存在的？

session在浏览器端，只需要保存session ID（由server端生成的唯一ID）就可以了。有两种保存方式：在cookie中、在url里面。如果cookie中保存session ID，就可以看到浏览器的cookie中有一个PHPSESID变量。如果是URL传递的，就可以看到形如:
index.php?PHPSESID=01aab840166fd1dc253e3b4a3f0b8381的URL。（在server端通过session.use_cookies来控制使用哪一种方式）

3. 在server端，php如何判断session文件是否过期？

如果”最后的修改时间”到”现在”超过了gc_maxlifetime（默认是1440）秒，这个session文件就被认为是过期了，在下一次session回收的时候，如果这个文件仍然没有被更改过，这个session文件就会被删除（session就过期了）。

简单的说，如果我登录到某网站，如果在1440秒（默认值）内没有操作过，那么对应的session就认为是过期了。

所以，修改php.ini文件中的gc_maxlifetime变量就可以延长session的过期时间了：（例如，我们把过期时间修改为86400秒）

session.gc_maxlifetime = 86400

然后，重启你的web服务（一般是apache）就可以了。

注意：php5里面session过期使用了回收机制。这里设置时间为86400秒，如果session在86400秒内没有被修改过，那么在下一次“回收”时才真的被删除。

3. session“回收”何时发生？

默认情况下，每一次php请求，就会有1/100的概率发生回收，所以可能简单的理解为“每100次php请求就有一次回收发生”。这个概率是通过以下参数控制的

#概率是gc_probability/gc_divisor
session.gc_probability = 1
session.gc_divisor = 100

注意1：假设这种情况gc_maxlifetime=120，如果某个session文件最后修改时间是120秒之前，那么在下一次回收（1/100的概率）发生前，这个session仍然是有效的。

注意2：如果你的session使用session.save_path中使用别的地方保存session，session回收机制有可能不会自动处理过期session文件。这时需要定时手动（或者crontab）的删除过期的session：cd /path/to/sessions; find -cmin +24 | xargs rm

4. 一些特殊情况

因为回收机制会检查文件的“最后修改时间”，所以如果某个会话是活跃的，但是session的内容没有改变过，那么对应的session文件也就没有改变过，回收机制会认为这是一个长时间没有活跃的session而将其删除。这是我们不愿看到的，可以通过增加如下的简单代码解决这个问题：

<?php  
if(!isset($_SESSION['last_access'])||(time()-$_SESSION['last_access'])>60)  
    $_SESSION['last_access'] = time();  
?>

代码会每隔60秒，尝试修改修改一次session。

总结：如果想修改session过期时间，修改变量gc_maxlifetime就可以了。php5的session采用被动的回收机制（garbage collection）。过期的session文件不会自己消失，而是通过触发“回收”来处理过期的session。

更多资源：

PHP Runtime Configuration

Pick up performance with generational garbage collection

shanyiwan@live.com(flyinweb) — Tue, 19 Jan 2010 10:05:26 GMT

Garbage collection (GC) reclaims the heap space previously allocated to objects no longer needed. The process of locating and removing those dead objects can stall your Java application while consuming as much as 25 percent of throughput.

Sun Microsystems introduced generational GC in the Java HotSpot VM for Solaris. Generational GC separates older and newer objects into separate heap spaces. With command line parameters, you control how the HotSpot JVM uses that heap space to perform GC. HotSpot's default parameters are effective for most small applications that require faster startup and a smaller footprint. But you can select parameters that activate the Java HotSpot Server VM to improve the throughput of large, server-side applications, like those running under BEA's WebLogic, by 20 percent or more.

This article is written from the perspective of the infrastructure architect, not the Java developer. I don't explain how to modify Java code to achieve better GC. Instead, I show how the HotSpot JVM uses the system resources allocated to it to provide significant throughput improvement with no code modifications.

Pre-HotSpot JVMs

Prior to HotSpot, most JVMs had three main GC problems. First, all objects were scanned during every GC. As the number of objects increased, this type of GC's performance time increased as well.

Second, partially accurate GC algorithms were conservative when reclaiming memory. These algorithms had difficulty differentiating between pointers and other data types. This often meant the algorithm would fail to collect all garbage for fear of eliminating valid data objects.

Third, a garbage collector used handles to refer indirectly to objects in memory. Those handles were thought to expedite and simplify object relocation during garbage collection; however, they proved to be a significant performance bottleneck. The inability to relocate objects caused significant memory fragmentation and prevented the use of more sophisticated GC algorithms. Other collectors used handleless objects, but when relocated objects were collected, all other objects had to be scanned so that pointers to relocated objects could be updated.

Post-HotSpot JVM

The Exact VM (JVM 1.2.2) introduced exact garbage collection. Sun then improved the exact GC design in JVM 1.3 and renamed it generational GC. Java HotSpot VM 1.3.1's GC is fully accurate, guaranteeing that:

You can reliably reclaim all inaccessible objects' memory
You can relocate all objects to compact memory, eliminating object memory fragmentation

The HotSpot JVM uses a two-machine-word object header, rather than the three-word header found in most other JVMs. This saves as much as 10 percent of the heap size for typical applications while accelerating the code to scan all objects.

The HotSpot JVM also eliminates the concept of handles. This reduces memory usage and speeds processing. In the HotSpot JVM, object references are implemented as direct pointers, providing C-speed access to instance variables.

Three types of collection algorithms

The HotSpot JVM provides three GC algorithms, each tuned for a specific type of collection within a specific generation. The copy (also known as scavenge) collection quickly cleans up short-lived objects in the new generation heap. The mark-compact algorithm employs a slower, more robust technique to collect longer-lived objects in the old generation heap. The incremental algorithm attempts to improve old generation collection by performing robust GC while minimizing pauses.

Copy/scavenge collection

Using the copy algorithm, the JVM reclaims most objects in the new generation object space (also known as eden) simply by making small scavenges -- a Java term for collecting and removing refuse. Longer-lived objects are ultimately copied, or tenured, into the old object space.

Mark-compact collection

As more objects become tenured, the old object space begins to reach maximum occupancy. The mark-compact algorithm, used to collect objects in the old object space, has different requirements than the copy collection algorithm used in the new object space.

The mark-compact algorithm first scans all objects, marking all reachable objects. It then compacts all remaining gaps of dead objects. The mark-compact algorithm occupies more time than the copy collection algorithm; however, it requires less memory and eliminates memory fragmentation.

Incremental (train) collection

The new generation copy/scavenge and the old generation mark-compact algorithms can't eliminate all JVM pauses. Such pauses are proportional to the number of live objects. To address the need for pauseless GC, the HotSpot JVM also offers incremental, or train, collection.

Incremental collection breaks up old object collection pauses into many tiny pauses even with large object areas. Instead of just a new and an old generation, this algorithm has a middle generation comprising many small spaces. There is some overhead associated with incremental collection; you might see as much as a 10-percent speed degradation.

The -Xincgc and -Xnoincgc parameters control how you use incremental collection. The next release of HotSpot JVM, version 1.4, will attempt continuous, pauseless GC that will probably be a variation of the incremental algorithm. I won't discuss incremental collection since it will soon change.

Performance factors

JVM performance is usually measured by its GC's effectiveness. "Tuning Garbage Collection with the 1.3.1 Java Virtual Machine" covers performance considerations in more depth. I will cover those factors that concern this article.

A JVM's throughput accounts for the percentage of total time GC does not take place. Therefore, 80 percent throughput implies that garbage collection consumes 20 percent of the JVM's processing while your application consumes only 80 percent. Throughput is also measured in pauses, during which your application stops processing while the JVM collects garbage.

Footprint accounts for the JVM's required amount of memory. On computers with limited memory, a large footprint can increase swapping and paging, where the operating system (OS) struggles to find free memory pages for the JVM to use. As OS paging increases, it consumes more processors and likely decreases the JVM's overall performance.

Command line parameters that divide the heap between new and old generations usually cause the greatest performance impact. If you increase the new generation's size, you often improve the overall throughput; however, you also increase footprint, which may slow down servers with limited memory.

Heap layout

The HotSpot JVM manages heap space in generations -- that is, memory pools for both new and old objects. As these objects accumulate, eventually a low memory condition occurs, forcing garbage collection to take place. Figure 1 illustrates the heap space divided into the old and the new generation.

Figure 1. Heap broken into its components

The new generation includes the new object space (eden), plus two survivor spaces (SS#1 and SS#2), as Figure 1 shows. New objects allocate in eden. Longer-lived objects are moved from the new generation and tenured to the old generation.

Figure 1 shows another heap section, called the permanent generation, which holds the JVM's class and method objects. The -XX:MaxPermSize=64m command line parameter controls the permanent generation's size. I won't discuss the permanent generation further in this article.

Control the heap size

You can control the heap size using several parameters. The -Xms and -Xmx parameters define the minimum and maximum heap sizes, respectively. Most large, server-side applications set the values equal to each other for a fixed heap size.

If you set those parameters unequal, then the JVM must increase or decrease the heap size at each collection; the objective is to keep the living object space's proportion within a specific range. The -Xminf and -Xmaxf parameters define the total heap size's minimum proportion and the maximum proportion, respectively.

If you use expandable heaps, you should bear in mind the impact of changing the old and new generation heap sizes. When the heap grows or shrinks, the JVM must recalculate the old and new generation sizes in order to maintain a predefined ratio (the NewRatio parameter).

The NewSize and MaxNewSize parameters control the new generation's minimum and maximum size, respectively. You can regulate the new generation size by setting these parameters equal. You can gain a fine granularity when using these parameters to tune the new generation.

Garbage collections

When the new generation fills up, it triggers a minor collection, in which surviving objects are moved to the old generation. When the old generation fills up, it triggers a major collection, which involves the entire object heap.

Minor collections

The Java HotSpot VM 1.3.1 uses copying collection for all minor collections. Figure 2's top portion shows that newly allocated objects (the blank circles) exist in eden. During a minor collection, the living objects (the dark circles) in eden are copied to the first survivor space. Once the copy is complete, you can use the entire eden space.

Figure 2. Minor collections. Click on thumbnail to view full-size image.

During the next GC, the living objects from eden and from the first survivor space are copied to the second survivor space. This is illustrated in Figure 2's middle portion, where all the living objects are copied, thus leaving only newly allocated objects in eden and the first survivor space.

The minor collection copies objects between survivor spaces until they become tenured; those objects are then copied to the old generation, as Figure 2's bottom portion shows.

Major collections

The Java HotSpot VM 1.3.1 uses mark-compact collection for all major collections; therefore, major collections occur in the old object space. Figure 3 illustrates the two-step process that comprises the mark-compact algorithm. During the first step, garbage collection goes through the entire heap, marking all unreachable objects (the red circles). During the second step, the unreachable objects (red circles) are compacted, leaving only live objects (the gray circles).

Figure 3. Major collections

Ratio of old to new generations

So far, my diagrams have casually drawn a line to separate the old and the new generations. The actual placement of the dividing line between the old and new generations is the most critical decision influencing HotSpot JVM performance. Every time you start the HotSpot JVM, you determine where to place this line by including or omitting one parameter.

NewRatio

You can divide the heap into old and new generations using the NewRatio parameter. If you use -XX:NewRatio=5, then you create an old-to-new ratio of 5:1; the old generation occupies 5/6 of the heap while the new generation occupies 1/6 of the heap. If you increase the new generation's size, minor collections may occur less often. However, because the -Xmx parameter sets the total heap size, you also decrease the old generation's size. This may increase the frequency of major collections.

Java HotSpot Client VM ratio

The Java HotSpot Client VM 1.3.1 replaces both the classic JVM and the JVM 1.2 just-in-time (JIT) compilers to improve runtime performance for applications and applets. The HotSpot Client JVM has been specially tuned to reduce application startup time and memory footprint, making it particularly well suited for client environments. On all platforms, the HotSpot Client JVM is the default.

The default NewRatio for the HotSpot Client JVM is 8; the old generation occupies 8/9 of the heap while the new generation occupies 1/9, as Figure 4 shows. This allocation is appropriate for client applications, like Java GUIs, that allocate many short-lived objects. Objects created to support a GUI window often do not live beyond the window display's life. After a few minor collections for longer-running applications where objects live longer, tenure occurs and the objects move to the old generation. Once this happens, every subsequent collection is commonly a major one.

Figure 4. Impact of NewRatio on generation sizes

Java HotSpot Server VM ratio

The Java HotSpot Server VM 1.3.1 is similar to the HotSpot Client JVM except that it has been specially tuned to maximize peak operating speed. It is intended for long-running server applications, for which the fastest possible operating speed is generally more important than having the fastest startup time. To invoke the HotSpot Server JVM instead of the default HotSpot Client JVM, use the -server parameter; for example, java -server MyApp.

The default NewRatio for the HotSpot Server JVM is 2; the old generation occupies 2/3 of the heap while the new generation occupies 1/3, as Figure 4 above shows. The larger new generation can accommodate many more short-lived objects, thus decreasing the need for slow major collections. The old generation is still sufficiently large enough to hold many long-lived objects.

Client JVM vs. Server JVM: Which is right for you?

There is no simple answer to the question of which HotSpot JVM is right for your application. Just because an application is long running doesn't mean it doesn't allocate many short-lived objects. Also, just because an application is a GUI doesn't mean it only allocates short-lived objects. Only you understand how your application creates and destroys objects.

The "Capture GC Statistics" section below explains how to determine GC behavior within your application. Poorly selected JVM parameters can severely degrade your application performance. For applications running under the WebLogic framework, I have often seen 20 to 30 percent performance improvement simply by adding the -server parameter, thereby selecting the HotSpot Server JVM over the default HotSpot Client JVM.

In general, if your Java application is a standalone program, the HotSpot Client JVM will probably give you the best performance. If your Java application executes within a server framework, such as BEA WebLogic, the HotSpot Server JVM will probably give you better performance. Try each and see what works best for your application.

Note: When no client or server parameter is provided, the Java HotSpot VM 1.3.1 uses its default value. The default is the first line in the jvm.cfg file, which is located in the <jvm_dir>/jre/lib directory. Rather than modifying all your startup scripts to add the -server parameter, you can make -server the first noncomment line in the file.

SurvivorRatio

The SurvivorRatio parameter controls the size of the two survivor spaces. For example, if you set the parameter to -XX:SurvivorRatio=10, the ratio between each survivor space and eden is 1:10. Since two survivor spaces exist, each survivor space will be 1/12 of the new generation.

While SurvivorRatio is generally less important to performance, you should know that the default setting is 25. Figure 5 shows a drawn-to-scale default HotSpot Server JVM heap with a NewRatio of 2 (i.e., the old generation is twice the size of the new generation) and a SurvivorRatio of 25 (i.e., a survivor space is 1/25 the size of eden).

Figure 5. SurvivorRatio default setting of 25

Word to the wise

To improve performance, it's important to keep eden smaller than half the heap size. This ensures that you have enough memory available to complete a minor collection. When you lack enough memory, a major collection will occur, which will bog down performance.

This means that the old generation must typically be larger than the new generation. One reason for this is that the HotSpot JVM guarantees that if everything is alive in eden, it can all be copied to the old space, so that every collection triggers a full GC. An exception is if you use the -XX:MaxLiveObjectEvacuationRatio=<n> parameter. This ratio lets you declare that you have short-lived objects and that the HotSpot JVM needn't worry about having a large enough old space. This parameter can be 0 if you want almost no old generation; the default value is 100, meaning that 100 percent of eden may contain live objects.

This gives you an idea of the level of control you can have over the way in which the HotSpot JVM uses the heap space you allocate to it. It should also show the level of understanding you should possess before using -XX parameters in production environments. For example, if you set the -XX:MaxLiveObjectEvacuationRatio=<n> parameter too low, you will continually get an out-of-memory error, so use it with extreme caution. (See "Sidebar 1: Support for -XX Parameters" at the end of this article.)

Analyze GC behavior

To determine which HotSpot JVM parameters are best for your application, you may need to ask the JVM to display information about its GC behavior.

Capture GC statistics

Every time the JVM performs a collection, the command line parameter -verbosegc instructs it to output the heap data. In the following sample output, there are four minor collections, one major collection, and then three more minor collections. The numbers before and after the arrow indicate the size of the live objects before and after the GC. The number in parentheses is the total heap size. In the first GC, 40,549 KB of objects existed before collection and 20,909 KB of objects after collection. This means that 19,640 KB of objects were dead and collected. The total heap size is 64,768 KB. The collection process required 0.0484179 seconds:

[GC 40549K->20909K(64768K), 0.0484179 secs]
[GC 41197K->21405K(64768K), 0.0411095 secs]
[GC 41693K->22995K(64768K), 0.0846190 secs]
[GC 43283K->23672K(64768K), 0.0492838 secs]
[Full GC 43960K->1749K(64768K), 0.1452965 secs]
[GC 22037K->2810K(64768K), 0.0310949 secs]
[GC 23098K->3657K(64768K), 0.0469624 secs]
[GC 23945K->4847K(64768K), 0.0580108 secs]

An awk script to analyze the GC data

The following awk script parses the output from -verbosegc on a Solaris computer, creating a file suitable for importing into Excel for graphing. (Why awk, you ask? As an infrastructure architect, not a Java developer, I felt more comfortable using awk.)

BEGIN {
  printf("Minor\tMajor\tAlive\tFreed\n")
}
{
  if ( substr(body,1,4) == "[GC " )  {
    # break each input line into 4 pieces in array[]
    split(body,array," ");
    # array[1]="[GC"
    # array[2]="20713K->549K(64768K),"
    # array[3]="0.0086130"
    # array[4]="secs]"
    printf("%s\t0.0\t",array[3])
    # break array[2]="43960K->1749K(64768K)," into 4 pieces in barray[]
    split(array[2],barray,"K")
    # barray[1]="43960"
    # barray[2]="->1749"
    # barray[3]="(64768"
    # barray[4]="),"
    before=barray[1]
    after=substr(barray[2],3)
    reclaim=before-after
    printf("%s\t%s\n",after,reclaim)
  }
  if ( substr(body,1,9) == "[Full GC " )  {
    # break each input line into 4 pieces in array[]
    split(body,array," ");
    # array[1]="[Full"
    # array[2]="GC"
    # array[3]="20713K->549K(64768K),"
    # array[4]="0.0086130"
    # array[5]="secs]"
    printf("0.0\t%s\t",array[4]) 
    # break array[2]="43960K->1749K(64768K)," into 4 pieces in barray[]
    split(array[3],barray,"K")
    # barray[1]="43960"
    # barray[2]="->1749"
    # barray[3]="(64768"
    # barray[4]="),"
    before=barray[1]
    after=substr(barray[2],3)
    reclaim=before-after
    printf("%s\t%s\n",after,reclaim)
  }
  # no idea what this line is so skip it
  next;
}

Here is sample output from the above awk script:

Minor       Major       Alive       Freed
0.0484179   0.0         20909       19640
0.0411095   0.0         21405       19792
0.0846190   0.0         22995       18698
0.0492838   0.0         23672       19611
0.0         0.1452965   1749        42211
0.0310949   0.0         2810        19227
0.0469624   0.0         3657        19441
0.0580108   0.0         4847        19098

I imported the awk script's output into MS Excel. Figure 6 illustrates a graph created from the two lefthand columns. It shows the frequency of minor and major collections plus the amount of time required to perform the GC (i.e., the pauses).

Figure 6. Sample graph of minor/major collections

Figure 7 illustrates a graph created from the two righthand columns. It shows the amount of memory live objects consumed following each GC, as well as the amount of memory freed when dead objects were reclaimed.

Figure 7. Sample graph of GC behavior

Tenure distribution

After objects have been collected several times, they become tenured and are promoted to the old generation. You can use the -XX:+PrintTenuringDistribution parameter to display the information the JVM uses during its tenure calculations.

The JVM attempts to keep a target percentage of the survivor spaces empty, as defined by the -XX:TargetSurvivorRatio parameter. The default value is 50, meaning that the goal is to empty one-half (50 percent) of the survivor capacity following GC. The JVM computes the desired survivor size as shown below, and then computes the object threshold. An object's threshold accounts for the number of times an object is copied before it is tenured; this is recalculated at each collection:

    (survivor_capacity * TargetSurvivorRatio) / 100 * sizeof(a pointer)

Below is sample output when running java -verbosegc -XX:+PrintTenuringDistribution MyApp. In the first GC, the desired survivor size is 393,216 bytes (384 KB) and the threshold is 1, meaning that objects will be tenured following one collection. Then the garbage collector goes through the ages, the number of times the collector decides not to promote:

[GC
Desired survivor size 393216 bytes, new threshold 1 (max 32)
- age   1:   509624 bytes,   509624 total
 20288K->497K(64768K), 0.0147963 secs]
[GC
Desired survivor size 393216 bytes, new threshold 32 (max 32)
- age   1:   169616 bytes,   169616 total
 27697K->6997K(64768K), 0.0038858 secs]
[GC
Desired survivor size 393216 bytes, new threshold 32 (max 32)
- age   1:   191392 bytes,   191392 total
- age   2:    52944 bytes,   244336 total
 27285K->7070K(64768K), 0.0046738 secs]
[GC
Desired survivor size 393216 bytes, new threshold 1 (max 32)
- age   1:   733488 bytes,   733488 total
- age   3:    52944 bytes,   786432 total
 27358K->7662K(64768K), 0.0148100 secs]

In the first GC above, objects occupying 509,624 bytes have already been copied once, meaning that they are in the first age bucket (age 1). In the third GC, there are objects occupying 191,392 bytes in the first age bucket and objects occupying 52,944 bytes in the second age bucket. Since the threshold is 32 during the third GC, you see that the objects were not tenured, because in the fourth GC there are objects occupying 52,944 bytes in the third age bucket.

(See "Sidebar 2: Performance Test Program" at the end of this article for information on Ed Ort's HeapTest program used to test parameters in this article.)

Take out the trash

Ordinarily, the Java developer doesn't have to be concerned with the complexity of memory allocation and GC within the JVM. However, understanding aspects of this hidden implementation can help you ensure effective resource use. Garbage collection algorithms make assumptions about the way applications use objects. The HotSpot JVM's tunable parameters let you adjust the GC algorithms to better meet your application's behavior characteristics. Sometimes just adding the -server parameter to switch from the default HotSpot Client JVM to the HotSpot Server JVM can improve throughput of WebLogic applications by 20 percent or more.

Stay tuned for the Java HotSpot VM 1.4 release, which will extend the train, or incremental, garbage collector algorithm to perform GC in parallel.

Apache patch for libexpat.so: could not read symbols: File in wrong format

shanyiwan@live.com(flyinweb) — Mon, 18 Jan 2010 09:19:15 GMT

If you want to compile Apache 2.2.4 under Red Hat AS 5.0 x86-64 you can get this error:

/usr/lib/libexpat.so: could not read symbols: File in wrong format

There is a patch in the ASF Bugzilla (http://issues.apache.org/bugzilla/show_bug.cgi?id=28205 ), but this patch works only up to version 2.2.3. So, i create a new one, which works with 2.2.4

Here it is http://blog.chaos-co.de/downloads/apr-util_2.2.4.patch

Unpack your apache with tar, go in the httpd-2.2.4/srclib/apr-util directory and apply it with "patch -p1 < /usr/local/src/apr-util_2.2.4.patch"

The patch updates apu-conf.m4 to build an updated configure that knows what to do with a 64 bit directive. So, once you’ve applied the patch, you should delete the file:

srclib/apr-util/configure

and go back to the root directory of the source distro and delete the configure file there too.

Then, rebuild the configure scripts:

./buildconf

You now have a 64 bit enabled apr-util. To take advantage of it, you need to add this line to the root configure options:

--enable-lib64

Here’s the root configure in full:

./configure --prefix=/usr/local/httpd-2.2.4_php4/ --with-mpm=worker --enable-so --enable-rewrite --enable-status --enable-lib64 --libdir=/usr/lib64

*********************************************************************

If you get this error

/usr/lib/libexpat.so: could not read symbols: File in wrong format

add the following option to your apache configure file:

--with-expat=builtin

You place that into:
/usr/local/directadmin/custombuild/configure/ap2/configure.apache
as:

"--with-expat=builtin" \

taking note of the \ character that must be present on all lines except for that last line.

Java Memory Analysis(Eclipse Memory Analyzer)

shanyiwan@live.com(flyinweb) — Mon, 18 Jan 2010 03:47:22 GMT

The Memory Analyzer is Open Source!

The Memory Analyzer is an Open Source Project at Eclipse (http://www.eclipse.org/mat/) licensed under the Eclipse Public License. Check out our blog, the WIKI and the forum. If you find a bug, please file it against Bugzilla.

While the open source version contains all the core features, the SAP Netweaver Extensions provide names for NetWeaver deployment units and information about caches, sessions, etc. The extensions are helpful if you analyze heap dumps from NetWeaver Java Server systems.

What does the Memory Analyzer do?

SAP Memory Analyzer is a fast and feature-rich heap analyzer that helps you easily find big chunks of memory and identify who is keeping these objects alive.

The Memory Analyzer was developed to analyze productive heap dumps with hundreds of millions of objects. Once the heap dump is parsed, you can re-open it instantly, immediately get the retained size of single objects and quickly approximate the retained size of a set of objects. The Analyzer is (relatively) low on resource consumption, so you can analyze multi-GB heap dumps on 32 bit boxes.

Read what our users have to say!

What heap dumps are supported?

SAP Memory Analyzer supports by default HPROF binary heap dumps, a de-facto standard of Sun supported also by other vendors:

Sun, SAP and HP JDK/JVM from version 1.4.2_12 and 5.0_7 and 6.0 upwards

Memory Analyzer can also read memory-related information from IBM system dumps. For the purpose one has to install the IBM DTFJ adapter into the Memory Analyzer. Minimum-required versions are:

IBM JDK 1.4.2 SR12, 5.0 SR8a and 6.0 SR2. Read more here.

On what platforms does the SAP Memory Analyzer run?

The Memory Analyzer is based on Eclipse 3.3 and needs a 1.5 JDK. You can either download the standalone application or unzip the plug-ins to your Eclipse installation. The former is available for all platforms that SWT is available. We greatly appreciate your feedback regarding platforms other than Windows as our scarce resources let us primarily target Windows.

How can I get a heap dump?

Please see here for details.

How can I get an HPROF heap dump?

Are you running an AS Java Weekstone with SAP JVM...

Use the ConfigTool to configure the following VM parameters:
-XX:+HeapDumpOnOutOfMemoryError
-XX:+HeapDumpOnCtrlBreak
In SAP MMC right-click on the AS Java server process and select Dump Stack Trace
The heap file is written to the working directory of the server, e.g. /usr/sap/<SID>/J<instance>/j2ee/cluster/server<node>/

...or a plain Java Application?

If you are running a SAP JVM, use ~/bin/jvmmon.exe
On a Sun or HP VM please see the table below.

All options to get an HPROF dump in detail...

via Java VM parameters (see ConfigTool on how to set those for AS Java installations):

-XX:+HeapDumpOnOutOfMemoryError writes heap dump on OutOfMemoryError (recommended)
-XX:+HeapDumpOnCtrlBreak writes heap dump together with thread dump on CTRL+BREAK (recommended; use SAP MMC to trigger dumps for AS Java installations)
-agentlib:hprof=heap=dump,format=b combines the above two settings (old way; not recommended as the VM frequently dies after CTRL+BREAK with strange errors)

via tools:

Sun JMap: jmap.exe -dump:format=b,file=HeapDump.hprof <pid>
Sun JConsole: Launch jconsole.exe and invoke operation dumpHeap() on HotSpotDiagnostic MBean
SAP JVMMon: Launch jvmmon.exe and call menu for dumping the heap

Heap dump will be written to the working directory.

Vendor / Release	VM Parameter			Sun Tools		SAP Tool
	On out of memory	On Ctrl+Break	Agent	JMap	JConsole	JVMMon
Sun, HP
1.4.2_12	Yes	Yes	Yes
1.5.0_07	Yes	Yes (Since 1.5.0_15)	Yes	Yes (Only Solaris and Linux)
1.6.0_00	Yes		Yes	Yes	Yes (Not working with AS Java)
SAP
Any 1.5.0	Yes	Yes	Yes	Yes (Only Solaris and Linux)		Yes

If you run into problems opening a heap dump with the SAP Memory Analyzer (Error message: "Unrecognized heap dump sub-record type"), please let us know. This indicates a corrupt heap dump file. In this case we would like to learn which tool/approach you have chosen to dump the heap.

When HPROF heap dumps are NOT written on OutOfMemoryError?

Heap dumps are not written on OutOfMemoryError for the following reasons:

Application creates and throws OutOfMemoryError on its own
Another resource like threads per process is exhausted
C heap is exhausted

As for the C heap, the best way to see that you won't get a heap dump is if it happens in C code (eArray.cpp in the example below):

# An unexpected error has been detected by SAP Java Virtual Machine:
# java.lang.OutOfMemoryError: requested 2048000 bytes for eArray.cpp:80: GrET*. Out of swap space or heap resource limit exceeded (check with limits or ulimit)?
# Internal Error (\\...\hotspot\src\share\vm\memory\allocation.inline.hpp, 26), pid=6000, tid=468

C heap problems may arise for different reasons, e.g. out of swap space situations, process limits exhaustion or just address space limitations, e.g. heavy fragmentation or just the depletion of it on machines with limited address space like 32 bit machines. The hs_err-file will help you with more information on this type of error. Java heap dumps wouldn't be of any help, anyways.

Also please note that a heap dump is written only on the first OutOfMemoryError. If the application chooses to catch it and continues to run, the next OutOfMemoryError will never cause a heap dump to be written!

How can I get an IBM system dump?

How to get an IBM system dump to be analyzed with Memory Analyzer + DTFJ Adapter depends on the concrete IBM system / JVM. The following resources should provide the necessary description:

SAP Note 1259465 - For NetWeaver 6.40 / 7.0x on AIX
SAP Note 1265455 - For NetWeaver 6.40 / 7.0x on pLinux (Linux on Power)
SAP Note 1263258 - For NetWeaver 6.40 / 7.0x on xLinux (IBM VM for Linux on x86_64)
SAP Note 1267126 - For NetWeaver 6.40 / 7.0x on IBM i
SAP Note 1336952 - For NetWeaver 6.40 / 7.0x on zLinux (Linux on System z)
The DTFJ Adapter Help available under the "Help" menu in Memory Analyzer after the DTFJ adapter is installed
IBM's Diagnosis documentation

Source From:wiki.sdn.sap.com/wiki/display/Java/Java+Memory+Analysis

flyinweb's blog

mysql slave延时同步

dlslaved 0.1

(Delayed Slave Daemon for MySQL)

Awk学习笔记

Awk学习笔记

整理：Jims of 肥肥世家

1. awk简介

2. awk命令格式和选项

2.1. awk的语法有两种形式

2.2. 命 令选项

3. 模式和操作

3.1. 模式

3.2. 操作

4. awk的环境变量

5. awk运算符

6. 记录和域

6.1. 记录

6.2. 域

6.3. 域分隔符

7. gawk专用正则表达 式元字符

8. POSIX字符集

9. 匹配操作符(~)

10. 比较表达式

11. 范围模板

12. 一个验证 passwd文件有效性的例子

13. 几个实例

14. awk编程

14.1. 变量

14.2. BEGIN 模块

14.3. END模块

14.4. 重定向和管道

14.5. 条件语句

14.5.1. if 语句

14.5.2. if/else语句，用于双重判断。

14.5.3. if/else else if语句，用于多重判断。

14.6. 循 环

14.7. 数组

14.7.1. 下 标与关联数组

14.8. awk的内建函数

14.8.1. 字符串函数

14.8.2. 时间函数

14.8.3. 内 建数学函数

14.8.4. 自定义函数

15. How-to

统计文件中字符出现次数

Informix主要系统表的结构及相关字段的含义

informx技术支持库

浅谈Java中的垃圾回收机制

php中session过期时间设置

Pick up performance with generational garbage collection

Pre-HotSpot JVMs

Post-HotSpot JVM

Three types of collection algorithms

Copy/scavenge collection

Mark-compact collection

Incremental (train) collection

Performance factors

Heap layout

Control the heap size

Garbage collections

Minor collections

Major collections

Ratio of old to new generations

NewRatio

Java HotSpot Client VM ratio

Java HotSpot Server VM ratio

Client JVM vs. Server JVM: Which is right for you?

SurvivorRatio

Word to the wise

Analyze GC behavior

Capture GC statistics

An awk script to analyze the GC data

Tenure distribution

Take out the trash

Apache patch for libexpat.so: could not read symbols: File in wrong format

Java Memory Analysis(Eclipse Memory Analyzer)

The Memory Analyzer is Open Source!

What does the Memory Analyzer do?

What heap dumps are supported?

2.2. 命令选项

7. gawk专用正则表达式元字符

14.6. 循环

14.7.1. 下标与关联数组

14.8.3. 内建数学函数