Linux下一般最常用的工具wu-ftpd.
wu-ftpd的安装非常容易，大多数版本的Linux中都包含了wu-ftpd的rpm软件包，你可以在安装Linux时指定装入。如果你想自行编译源代码，也可以到ftp://ftp.wu-ftpd.org下载最新版本的源代码包。
安装好以后，可以用ckconfig命令来检查是否已经正确安装。在/etc/passwd中可以指定ftp用户的登入目录。
wu-ftpd主要有以下6个配置文件：
ftpaccess(主要配置文件，控制存取权限)
ftpconvertions(配置文件压缩/解压缩转换)
ftpgroups(设定ftp自己定义的群组)
ftphosts(设定个别的用户权限)
ftpservers(设定不同IP/Domain Name以对应到不同的虚拟主机)
ftpusers(设定哪些帐号不能用ftp连线)
下面我们来一一介绍。
⒈/etc/ftpaccess(wu-ftpd的主要配置文件)
class--定义群组，用法如下：
class<种类><用户地址>[<用户地址>……]
由class定义的群组用户才可以连线进来，可以使用多层式的class来规范哪些群组的用户能够从哪些地方上来。这里有三个重要的种类，real、anonymous个guest。real如果没有列在定义中，那么这台机器中任何真实的一般用户都无法用自己的帐号连上来。anonymous如果没有在定义，就表示不让没有帐号的的人连上来。如果有定义guest，那么guest群组的人就可以上来。另外<用户地址>是指ftp上来的用户会用到的IP地址，则可自行设定。以下是一些例子：
class all real,guest,anonymous *
定义了一个名为all的class，包含三种人，所有IP的连线用户(也就是所有人都包括了)
class local real localhost loopback
local这个class说，只有real的用户可以从本机机器连上来
class remote guest,anonymous *
remote这个class包含了从任何地方上来的guest和anonymous用户，但是real用户不算
class rmtuser real !*.example.com
rmtuser这个class包含了从外面来的(除了example.com)真实用户
autogroup--自动对应群组，用法如下：
autogroup[……]
当你定义好的那些同属于一个class的用户，一旦连线上来就会被对应到一个相应的群组下面，这样你就可以用Unix的文件权限对某一群人做限制。
deny--拒绝某些地址连线，用法如下：
deny<拒绝连线的地址><信息文件>
禁止某些机器连线，并显示<信息文件>。例如：
deny 210.62.146.*:255.255.255.254 /etc/reject.msg
guestgroup--设定访客群
guestuser--设定访客帐号
realgroup--设定真实群组
realuser--设定真实帐号
nice--设定给某些class多少优先权，用法如下：
nice
在Linux中，nice的值是-20(最优先)到19(最后处理)，这里你可以指定负的值来提高某class的优先顺序。
defumask--设定某class的umask，用法如下：
defumask[]
umask是建立文件时该文件的的权限掩码
tcpwindow--设定tcpwindow的大小
keepalive--设定是否使用TCP SO_KEEPALIVE来控制断线情形
timeout--设定连线超时，用法如下：
timeout accept<秒>
接受连线超时，预设120秒
timeout connect<秒>
连线建立超时，预设120秒
timeout data<秒>
数据传送超时，预设1200秒
timeout idle<秒>
用户发呆超时，预设900秒
file-limit--限制某class只能传几个文件，用法如下：
file-limit[][]
对某个class限制存取文件的数目，包含了in(上传)、out(下载)，total raw代表整个传输的结果，不光是数据文件。例如：
file-limit out 20 lvfour
限制lvfour这个class的用户最多只能下载20个文件
byte-limit--限制某class只能传几个字节，用法跟file-limit相似
limit-time--限制一个连线只能持续多久，用法如下：
limit-time{*|anonymous|guest}<分钟>
为了避免有人挂在站上不下来，可以用这个方法限制用户的上线时间，例如：
limit-time guest 5
让guest帐号的用户只能用5分钟
limit--限制某class能同时几人上线，用法如下：
limit<连线数目><时间区段><额满信息文件>
设定某个class在某一时间区段内最多能够几人同时上线，后面是当超过连线数目时要显示的信息。例如：
limit all 32 Any /home/ftp/etc/toomanyuser.msg
限制所有连线在任何时间只能有32个用户，超过则拒绝连线并显示信息
limit levellone 5 Any2300-0600 /home/ftp/etc/toomanyuser.msg
限制levellone这个class的用户在23:00到6:00这段时间内只能有5人连线
noretrieve--设定哪些文件不可下载
noretrieve[absolute/relative][class=]…[-][<文件名>…]
absolute或relative指文件是用绝对路径还是相对路径
allow=retrieve--设定哪些文件可以下载
allow[absolute/relative][class=]…[-][<文件名>…]
loginfails--设置登入错误可尝试的次数
当用户连线时可能打错ID或密码，这个设定可以让他打错几次以后就断线，避免有人用穷举法猜测密码。
private--设定线上是否可以执行SITE GROUP/SITE GPASS
当开放SITE GROUP与SITE GPASS指令时，可以用这两个指令切换到/etc/ftpgroup的群组。一般而言我们不会用到这个功能，以避免安全漏洞。
greeting--显示Server的版本信息，用法如下：
greeting
当用户登入画面显示的server信息，full是预设值，包含版本号以及hostname，brief只有hostname，而terse只有“FTP server ready”的信息。
barnner--设定未进入Login画面之前用户看到的信息，用法如下：
banner<文件路径>
这里叙述了在用户登入时，在还没打ID/Password之前要出现的信息。文件路径指的是相对于真实的路径，而不是相对于ftp的根目录。
host--设定ftp主机名
email--指定ftp管理者的email地址
message--信息文件的设定，用法如下：
message<文件>{<何时>{……}}
这里的文件的路径是相对于ftp的根目录的，“何时”是指当你做了什么动作之后的反应，有几个选择：
login(登入时)
cwd=<目录>(进入某目录时)
class 名称是前面已经定义过的，允许你的信息只对哪些人发出。
而信息文件的内容除了文字以外，还可以使用以下一些事先定义好的代号：
%T(本机时间)
%F(目前分区所剩余的空间)
%C(目前所在的目录)
%E(管理者的E-mail)
%R(客户端主机名称)
%L(本机主机名称)
%U(用户名称)
%M(与我相同class用户允许多少人连线)
%N(与我相同class用户目前有多少人连线)
%B(绝对磁盘限制大小，目前分区(单位blocks))
%b(preferred磁盘限制大小，目前分区(单位blocks))
%Q(目前已使用的blocks)
%I(最大可使用的inodes(+1))
%i(Preferred inodes限制)
%q(目前使用的indoes)
%H(超量使用磁盘空间的时间限制)
%h(超量使用文件数目的时间限制)
readme--通知用户哪些README文件已经更新
log commands--记录用户所使用过的命令，用法如下：
log commands<用户种类>
log transfers--记录用户所传输的文件，用法如下：
log transfers<用户种类><传输方向>
设定有哪些类型的用户传输文件需要记录，包含了inbound(用户上传)和outbound(用户下载)，例如：
log transfers anonymous,guest inbound,outbound
log security--记录安全性，用法如下：
log security<用户种类>
特别用于记录某类用户关于noretrive、notar等有关安全性的记录
log syslog--记录到系统的syslog文件
alias--设定目录别名，用法如下：
alias<别名字符串><目录>
cdpath--设定cd更换目录搜索顺序
compress,tar--设定是否自动压缩，用法如下：
compress[……]
tar[……]
定义哪些人可以执行压缩以及tar
shutdown--通知用户要关站了
shutdown<信息文件>
如果信息文件存在的话，当这个文件指定的某时间以后，就会拒绝连线并切断已有的连线，等时间一到就关机。这个信息文件的格式如下：
<年><月><日><时><分><拒绝倒数><断线倒数><文字>
daemon address--指定只监听某个IP地址，用法如下：
daemon address
当你有许多IP的时候，使用这个选项将会取消其它任何虚拟FTP主机的设定。不设定的话，监听所有IP。
virtual--设定虚拟FTP站台
wu-ftpd提供了虚拟主机的功能，也就是说，在同一台机器上提供了不同FTP站台，以主机名称或IP来区分；当然你要用名称的话，还需要跟DNS配合才行。virtual有很多个设定：
virtual
<路径>
可以是主机名或IP地址
root指的是ftp的根目录，banner是欢迎信息，logfile指的是这个虚拟站台的log文件
以下是一些例子：
virtual virtual.com.bj root /home/ftp2
virtual virtual.com.bj banner /etc/vftpbanner.2
virtual virtual.com.bj logfile /etc/viftplog.2
virtual
<字母>
用户可以查到hostname跟管理者email，以下是一些例子：
virtual 210.62.146.50 hostname virtual.site.com.bj
virtual vritual.site.com.bj email ftpown@virtual.site.com.bj
virtual
allow<用户>[<用户>……]
virtual
deny<用户>[<用户>……]
很明显，以上两个选项是设定是否允许连线的，以下是一些例子：
virtual virtual.site.com.bj allow *
virtual virtual.site.com.bj deny badman
virtual
private
本虚拟站台拒绝anonymous用户
defaultserver deny <用户>[<用户>……]
defaultserver allow <用户>[<用户>……]
当我们使用了虚拟主机，原先的deny，allow设定不知道要设哪个server，所以会无效，用defaultserver代表原来的主机
defaultserver private
主站台拒绝anonymous用户
passive address--转换IP数值
passive address<外部IP>/cidr
passive ports--passive的ports范围
passive ports
pasv-allow--允许使用pasv
pasv-allow[<地址>……]
port-allow--允许使用port
port-allow[<地址>……]
mailserver--指定Upload通知的mail服务器
incmail--指定anonymous upload的email通知地址
virtual incmail--指定虚拟主机anonymous upload的email通知地址
defaultserver incmail--指定预设主机anonymous upload的email通知地址
mailfrom--通知的寄信人upload
virtual mailfrom--虚拟主机upload通知的寄信人
defaultserver mailfrom--预设主机upload通知的寄信人
chmod--设定是否可以改变文件权限
delete--设定是否可以删除文件
overwrite--覆盖文件
rename--重命名文件
umask--允许设定umask
passwd-check--设定anonymous FTP的密码检查程度，用法如下：
passwd-check()
设定对anonymous ftp用户的密码是否检查，none表示不检查，trivial为包含@的任意密码，rfc822则表示密码要遵循RFC822格式，enforce表示密码检查不过不允许进入，warn表示密码检查不过只出现警告信息。
deny=email--拒绝特定的email当密码
path-filer--摄定哪些文件名不可使用
path-filer<错误信息文件><允许字符><不允许字符>
upload--设定upload权限
upload[absloute/relative][class=]…[-]<设定的目录>>[dirs/nodirs][d_mode]
用来对我们要设定的目录做权限设定：
absoulte/relative使用绝对路径或是相对路径
class=指定某个class
root-dir指的是对哪些root-dir的人，也就是chroot后的登入目录，应用这个规则
设定的目录指的就是我们要限制的目录
yes/no指得是能否在此目录下开新文件
owner,group指出是开出来的文件拥有者及群组
Mode指的是文件权限
dirs/nodirs指的是能否开新目录
d_mode设定建立新目录时目录的权限，如果不设定会根据mode来设定
thoughput--控制下载速度
thoughput<子目录列表><文件><远端地址列表>
对远端的地址，控制他抓某个子目录下的某些文件时的速度，例如：
thoughput /e/ftp * * oo - *
thoughput /e/ftp /sw* * 1024 0.5 *
thoughput /e/ftp sw* readme oo - *
thoughput /e/ftp sw* * oo - *.foo.com
以上的设定你是否能够看出来呢？“oo”表示不限制bytes/sec，“-”或是“1.0”都是代表一倍。第一行的意思是说，在/e/ftp下面的文件不限制下载速度；第二行说，在/sw*下面的任何文件限速为1024bytes/sec*
0.5=512bytes/sec；第三行又把readme文件的限速取消；最后一行则对*.foo.com开放全速。
anonymous-root--对某class设定匿名用户的根目录
anonymous-root[]
guest-root--预设一个guest用户根目录
guest-root[]
其中用于指定uid的范围
deny-uid，deny-gid--拒绝某段UID(GID)范围
allow-uid，allow-gid--允许某段UID(GID)范围
restricted-uid，restricted-gid--限制用户不能离开他的登录目录
unrestricted-uid，unrestricted-gid--用户可以离开他的登录目录
dns refuse_mismatch--设定DNS查到名称与用户设定不符的动作
dns refuse_mismatch<信息文件>[override]
当用户使用未注册IP时，拒绝他的连线，override则是不理会错误而让他连线，信息文件则是我们要给用户看的。
dns refuse_no_reverse--设定无反查记录拒绝连线
dns refuse_no_reverse<信息文件>[override]
当用户的IP反查无记录时，拒绝他的连线
dns resolveoptions--设定DNS解析选项
dns resolveoptions[options]
这里可以设定DNS解析选项
⒉/etc/ftphosts
ftphosts文件其实跟ftpaccess里面的access，deny很像，它是特别用来设定某些ID的连线，它没有class定义，所以必须是真实用户。
allow|deny<用户><地址>[<地址>……]
以下是一些例子：
allow rose 140.0.0/8
deny jack 140.123.0.0:255.255.0.0
允许rose从140.*.*.*进来，拒绝jack从140.123.*.*上来
⒊/etc/ftpservers
这个文件控制了当你有不同的IP/hostname的时候，进来的连线使用哪一个配置文件。例如：
10.196.145.10 /etc/ftpd/ftpaccess.somedomain/
10.196.145.200 /etc/ftpd/ftpaccess.someotherdomain/
some.domain internal
10.196.145.20 /etc/ftpd/config/faqs.org/
ftp.some.domain /etc/ftpd/config/faqs.org/
⒋/etc/ftpusers
在这个文件里记录的用户禁止使用FTP
⒌/etc/ftpgroups
给SITE GROUP指令使用，线上切换group。SITE EXEC容易造成安全漏洞，一般我们都不开放。
⒍/etc/ftpconversions
用来做tar、compress、gzip等动作指令配置文件，只要用预设即可，如果你不开放即时压缩打包，也可以把内容清除。
2，Linux *** 作系统近几年有了蓬勃的发展，在整个世界范围内得到了越来越多公司和团体的支持，尤其是最近IBM公司的鼎力支持，更是使Linux服务器如虎添翼，更上一层楼
Linux *** 作系统近几年有了蓬勃的发展，在整个世界范围内得到了越来越多公司和团体的支持，尤其是最近IBM公司的鼎力支持，更是使Linux服务器如虎添翼，更上一层楼。而在国内，Linux的应用也是方兴未艾，众多公司已经投入到Linux系统的研发和推广工作中。一些优秀的Linux *** 作系统相继出现，比如红旗Linux等。但是我国的Linux应用水平还很低，熟悉Linux的人员严重缺乏，Linux专业人才的缺乏已成为Linux在国内应用和普及的瓶颈问题。据《开放系统世界》2003年第八期介绍，中国五年内Linux人才需求量将会超过120万。而“1+1+1”工程的实施，也是间接地告诉我们这个问题的严重性。如此大好时机，我们干吗还愣着不动呢！如果你是一位Linux爱好者，你可能已经掌握了基本的Linux的知识与 *** 作，毫无疑问，你并不会去满足这样小小的成就。Linux为何如此的流行？其最大的特点莫过于功能强大，性能稳定的服务器应用了。像WWW,MAIL,FTP,DNS和SMB等。在这篇文章中，我将以Redhat Linux 9为蓝本，从Web服务器的一些最基本的 *** 作入手，从初学者使用的态度，让读者正确充分的认识Apache。好，现在就让我们一起踏上征服Apache的自由之路吧。
Apache的主要特征是：
. 可以运行上所有计算机平台；
. 支持最新的HTTP 1.1协议；
. 简单而强有力的基于文件的配置；
. 支持通用网关接口CGI；
. 支持虚拟主机；
. 支持HTTP认证；
. 集成Perl脚本编程语言；
. 集成的代理服务器；
. 具有可定制的服务器日志；
. 支持服务器端包含命令（SSI）
. 支持安全Socket层（SSL）
. 用户会话过程的跟踪能力；
. 支持FastCGI；
. 支持Java Servlets。
安装Apache
下面我们就开始漫漫征服Apache之旅，通过循序渐进的需求实例，一步步地学习使用Apache，从入门到精通。
系统需求
运行Apache不需要太多的计算资源。它在有6-10MB硬盘空间和8MB RAM的Linux系统上运行得很好。然而，只运行Apache可能不是你想做的事情。更可能的是，你想运行Apache来提供WWW服务、启动CGI进程以及充分利用所有WWW能够提供的令人惊奇的功能。在这种情况下，你需要提供反映负载要求的额外的磁盘空间和内存空间。也就是说，如果仅仅是启动WWW服务并不需要太多的系统资源，但是想要能为大量的客户提供服务就需要更多的系统资源。
获取软件
你可以在http://www.apache.org中获得Apache的最新版。而几乎所有的Linux发行版中均包含有Apache软件包，你也可以直接使用它。
需要注意的是，Apache软件包有两种：一种是源代码，下载后需要自己重新编译；另一种是可执行文件，下载后只需解压就可以使用。
安装软件
你可以通过以下三种方法安装Apache服务器。
1．如果你安装的Linux版本中带用Apache的话，就在选择所要安装的服务器的时候，将httpd这个服务选上，Linux安装程序将自动完成Apache的安装工作，并做好基本的配置。
2．使用可执行文件软件包，这比较适合那些对编译工作不是太熟悉的初级用户，因为它相对比较简单。
下载软件包apache_1.2.4.e.tar.gz
tar xvzf apache_1.2.4.e.tar.gz
这就完成了安装工作，简单吧！
如果你使用的是RedHat Linux的话，你也可以下载apache_1.2.4.rpm软件安装包，然后使用rpm -ivh apache_1.2.4.rpm命令安装。
3．如果你想把Apache服务器充分利用起来的话，就一定要自己编译Apache定制其功能。
下载包含Apache源代码的软件包apache_1.2.4.tar.gz； 然后用tar命令将它解开； 将当前目录改变为Apache源代码发行版的src目录； 将配置样本文件（Configuration.tmpl）复制为Configuration文件；
编辑Configuration文件中的配置选项：
Makefile配置选项：一些编译选项：
. "CC="一行指定用什么编译软件编译，一般为"CC=gcc"；
. 如果需要将额外的标志（参数）指定给C编译软件，可以使用：
EXTRA_CFLAGS=
EXTRA_LFLAGS=
. 如果系统需要特殊的库和包含文件，可以在这里指定它们：
EXTRA_LIBS=
EXTRA_INCLUDES=
. 如果你要改变代码优化设置的话，你须将下面一句去掉注释，然
后改成你所需要的值：
#OPTIM=-O2
Rule配置选项：用来决定需要什么功能，一般情况下无需改变。
模块配置：模块是Apache的组成部分，它为Apache内核增加新功能。通过使用模块配置，可以自定义在Apache服务器中需要什么功能，这个部分也是Apache灵活性的表现。模块配置行如下所示：
AddModule modules/standard/mod_env.o
如果你需要Apache服务器具备什么功能，就将那个模块用AddModule语句加到配置文件Configuration中去。
3，一、 MYSQL的基本概念
1、MYSQL的定义
MYSQL一种多用户、多任务的数据库服务器软件
2、MYSQL的特点
支持多平台，没有内存漏洞，分布式处理
支持JAVA、PHP、PERL、支持数据类型
支持ODBC，支持SQL查询
二、 安装MYSQL的服务器
1、 RPM方式MYSQL
#RPM –ivh MYSQL-3。23-3.i386.rpm
#RPM –ivh MYSQL-client-3.23-33.i386.rpm
#RPM-ivh MYSQL-Shared.3.23-33.i386.rpm
#Tpm -ivh MYSQL –server.3.23-33.i386.rpm
2.编译安装方式
#tar -xvzf mysql 3.23.tar.gz
# cdmysql-3.23
#/configure --prdfix=/usr/local
#make
#malke install
# cd/usr/local/bin/
#/mysql-install-db 初始数据库系统。
系统库作用：记录服务器的设置参数，存放用户库信息
安全选项
#safe-mysqld
【Web服务器超时处理】[ Apache ]
一般在性能很高的情况下，缺省所有超时配置都是30秒，但是在上传文件，或者网络速度很慢的情况下，那么可能触发超时 *** 作。
目前apachefastcgiphp-fpm模式下有三个超时设置：
fastcgi超时设置：
修改的fastcgi连接配置，类似如下：
复制代码 代码如下:
<IfModulemod_fastcgi.c>
FastCgiExternalServer/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/php-fpm.sock
ScriptAlias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
AddHandlerphp-fastcgi.php
Actionphp-fastcgi/fcgi-bin/php-cgi
AddTypeapplication/x-
</IfModule>
缺省配置是30s，如果需要定制自己的配置，需要修改配置，比如修改为100秒：(修改后重启apache)：
复制代码 代码如下:
<IfModulemod_fastcgi.c>
FastCgiExternalServer/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/php-fpm.sock-idle-timeout100
ScriptAlias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
AddHandlerphp-fastcgi.php
Actionphp-fastcgi/fcgi-bin/php-cgi
AddTypeapplication/x-
</IfModule>
如果超时会返回500错误，断开跟后端php服务的连接，同时记录一条apache错误日志：
[ThuJan2718:30:152011][error][client10.81.41.110]FastCGI:commwithserver"/home/forum/apache/apache_php/cgi-bin/php-cgi"aborted:idletimeout(30sec)
[ThuJan2718:30:152011][error][client10.81.41.110]FastCGI:incompleteheaders(0bytes)receivedfromserver"/home/forum/apache/apache_php/cgi-bin/php-cgi"
其他fastcgi配置参数说明：
复制代码 代码如下:
IdleTimeout发呆时限
ProcessLifeTime一个进程的最长生命周期，过期之后无条件kill
MaxProcessCount最大进程个数
DefaultMinClassProcessCount每个程序启动的最小进程个数
DefaultMaxClassProcessCount每个程序启动的最大进程个数
IPCConnectTimeout程序响应超时时间
IPCCommTimeout与程序通讯的最长时间，上面的错误有可能就是这个值设置过小造成的
MaxRequestsPerProcess每个进程最多完成处理个数，达成后自杀
[ Lighttpd ]
配置：lig
Lighttpd配置中，关于超时的参数有如下几个（篇幅考虑，只写读超时，写超时参数同理）：
主要涉及选项：
server.max-keep-alive-idle=5
server.max-read-idle=60
server.read-timeout=0
server.max-connection-idle=360
复制代码 代码如下:
#每次keep-alive的最大请求数,默认值是16
server.max-keep-alive-requests=100
#keep-alive的最长等待时间,单位是秒，默认值是5
server.max-keep-alive-idle=1200
#lighttpd的work子进程数，默认值是0，单进程运行
server.max-worker=2
#限制用户在发送请求的过程中，最大的中间停顿时间(单位是秒)，
#如果用户在发送请求的过程中(没发完请求)，中间停顿的时间太长，lighttpd会主动断开连接
#默认值是60(秒)
server.max-read-idle=1200
#限制用户在接收应答的过程中，最大的中间停顿时间(单位是秒)，
#如果用户在接收应答的过程中(没接完)，中间停顿的时间太长，lighttpd会主动断开连接
#默认值是360(秒)
server.max-write-idle=12000
#读客户端请求的超时限制，单位是秒,配为0表示不作限制
#设置小于max-read-idle时，read-timeout生效
server.read-timeout=0
#写应答页面给客户端的超时限制，单位是秒，配为0表示不作限制
#设置小于max-write-idle时，write-timeout生效
server.write-timeout=0
#请求的处理时间上限，如果用了mod_proxy_core，那就是和后端的交互时间限制,单位是秒
server.max-connection-idle=1200
说明：
对于一个keep-alive连接上的连续请求，发送第一个请求内容的最大间隔由参数max-read-idle决定，从第二个请求起，发送请求内容的最大间隔由参数max-keep-alive-idle决定。请求间的间隔超时也由max-keep-alive-idle决定。发送请求内容的总时间超时由参数read-timeout决定。Lighttpd与后端交互数据的超时由max-connection-idle决定。
延伸阅读：
[ Nginx ]
配置：nf
复制代码 代码如下:
http{
#Fastcgi:(针对后端的fastcgi生效,fastcgi不属于proxy模式)
fastcgi_connect_timeout5#连接超时
fastcgi_send_timeout10#写超时
fastcgi_read_timeout10#读取超时
#Proxy:(针对proxy/upstreams的生效)
proxy_connect_timeout15s#连接超时
proxy_read_timeout24s#读超时
proxy_send_timeout10s#写超时
}
说明：
Nginx 的超时设置倒是非常清晰容易理解，上面超时针对不同工作模式，但是因为超时带来的问题是非常多的。
延伸阅读：
ml
ml
ml
【PHP本身超时处理】
[ PHP-fpm ]
配置：nf
复制代码 代码如下:
<?xmlversion="1.0"?>
<configuration>
//...
Setsthelimitonthenumberofsimultaneousrequeststhatwillbeserved.
EquivalenttoApacheMaxClientsdirective.
EquivalenttoPHP_FCGI_CHILDRENenvironmentinoriginalphp.fcgi
Usedwithanypm_style.
#php-cgi的进程数量
<valuename="max_children">128</value>
Thetimeout(inseconds)forservingasinglerequestafterwhichtheworkerprocesswillbeterminated
Shouldbeusedwhen'max_execution_time'inioptiondoesnotstopscriptexecutionforsomereason
'0s'means'off'
#php-fpm 请求执行超时时间，0s为永不超时，否则设置一个 Ns 为超时的秒数
<valuename="request_terminate_timeout">0s</value>
Thetimeout(inseconds)forservingofsinglerequestafterwhichaphpbacktracewillbedumpedtoslow.logfile
'0s'means'off'
<valuename="request_slowlog_timeout">0s</value>
</configuration>
说明：
在php.ini中，有一个参数max_execution_time可以设置PHP脚本的最大执行时间，但是，在php-cgi(php-fpm)中，该参数不会起效。真正能够控制PHP脚本最大执行时：
<valuename="request_terminate_timeout">0s</value>
就是说如果是使用mod_php5.so的模式运行max_execution_time是会生效的，但是如果是php-fpm模式中运行时不生效的。
延伸阅读：
[ PHP ]
配置：php.ini
选项：
max_execution_time=30
或者在代码里设置：
ini_set("max_execution_time",30)
set_time_limit(30)
说明：
对当前会话生效，比如设置0一直不超时，但是如果php的safe_mode打开了，这些设置都会不生效。
效果一样，但是具体内容需要参考php-fpm部分内容，如果php-fpm中设置了request_terminate_timeout的话，那么max_execution_time就不生效。
【后端&接口访问超时】
【HTTP访问】
一般我们访问HTTP方式很多，主要是：curl,socket,file_get_contents()等方法。
如果碰到对方服务器一直没有响应的时候，我们就悲剧了，很容易把整个服务器搞死，所以在访问http的时候也需要考虑超时的问题。
[ CURL 访问HTTP]
CURL 是我们常用的一种比较靠谱的访问HTTP协议接口的lib库，性能高，还有一些并发支持的功能等。
CURL:
curl_setopt($ch,opt)可以设置一些超时的设置，主要包括：
*(重要)CURLOPT_TIMEOUT设置cURL允许执行的最长秒数。
*(重要)CURLOPT_TIMEOUT_MS设置cURL允许执行的最长毫秒数。(在cURL7.16.2中被加入。从PHP5.2.3起可使用。)
CURLOPT_CONNECTTIMEOUT在发起连接前等待的时间，如果设置为0，则无限等待。
CURLOPT_CONNECTTIMEOUT_MS尝试连接等待的时间，以毫秒为单位。如果设置为0，则无限等待。在cURL7.16.2中被加入。从PHP5.2.3开始可用。
CURLOPT_DNS_CACHE_TIMEOUT设置在内存中保存DNS信息的时间，默认为120秒。
curl普通秒级超时：
$ch=curl_init()
curl_setopt($ch,CURLOPT_URL,$url)
curl_setopt($ch,CURLOPT_RETURNTRANSFER,1)
curl_setopt($ch,CURLOPT_TIMEOUT,60)//只需要设置一个秒的数量就可以
curl_setopt($ch,CURLOPT_HTTPHEADER,$headers)
curl_setopt($ch,CURLOPT_USERAGENT,$defined_vars['HTTP_USER_AGENT'])
curl普通秒级超时使用：
curl_setopt($ch,CURLOPT_TIMEOUT,60)
curl如果需要进行毫秒超时，需要增加：
curl_easy_setopt(curl,CURLOPT_NOSIGNAL,1L)
或者是：
curl_setopt($ch,CURLOPT_NOSIGNAL,true)是可以支持毫秒级别超时设置的
curl一个毫秒级超时的例子：
复制代码 代码如下:
<?php
if(!isset($_GET['foo'])){
//Client
$ch=curl_init('')
curl_setopt($ch,CURLOPT_RETURNTRANSFER,true)
curl_setopt($ch,CURLOPT_NOSIGNAL,1)//注意，毫秒超时一定要设置这个
curl_setopt($ch,CURLOPT_TIMEOUT_MS,200)//超时毫秒，cURL7.16.2中被加入。从PHP5.2.3起可使用
$data=curl_exec($ch)
$curl_errno=curl_errno($ch)
$curl_error=curl_error($ch)
curl_close($ch)
if($curl_errno>0){
echo"cURLError($curl_errno):$curl_errorn"
}else{
echo"Datareceived:$datan"
}
}else{
//Server
sleep(10)
echo"Done."
}
?>
其他一些技巧：
1. 按照经验总结是：cURL版本>=libcurl/7.21.0版本，毫秒级超时是一定生效的，切记。
2. curl_multi的毫秒级超时也有问题。。单次访问是支持ms级超时的，curl_multi并行调多个会不准
[流处理方式访问HTTP]
除了curl，我们还经常自己使用fsockopen、或者是file *** 作函数来进行HTTP协议的处理，所以，我们对这块的超时处理也是必须的。
一般连接超时可以直接设置，但是流读取超时需要单独处理。
自己写代码处理:
复制代码 代码如下:
$tmCurrent=gettimeofday()
$intUSGone=($tmCurrent['sec']-$tmStart['sec'])*1000000
+($tmCurrent['usec']-$tmStart['usec'])
if($intUSGone>$this->_intReadTimeoutUS){
returnfalse
}
或者使用内置流处理函数stream_set_timeout()和stream_get_meta_data()处理：
复制代码 代码如下:
<?php
//Timeoutinseconds
$timeout=5
$fp=fsockopen("",80,$errno,$errstr,$timeout)
if($fp){
fwrite($fp,"GET/HTTP/1.0rn")
fwrite($fp,"Host:rn")
fwrite($fp,"Connection:Closernrn")
stream_set_blocking($fp,true)//重要，设置为非阻塞模式
stream_set_timeout($fp,$timeout)//设置超时
$info=stream_get_meta_data($fp)
while((!feof($fp))&&(!$info['timed_out'])){
$data.=fgets($fp,4096)
$info=stream_get_meta_data($fp)
ob_flush
flush()
}
if($info['timed_out']){
echo"ConnectionTimedOut!"
}else{
echo$data
}
}
file_get_contents超时：
复制代码 代码如下:
<?php
$timeout=array(
'http'=>array(
'timeout'=>5//设置一个超时时间，单位为秒
)
)
$ctx=stream_context_create($timeout)
$text=file_get_contents("",0,$ctx)
?>
fopen超时：
复制代码 代码如下:
<?php
$timeout=array(
'http'=>array(
'timeout'=>5//设置一个超时时间，单位为秒
)
)
$ctx=stream_context_create($timeout)
if($fp=fopen("","r",false,$ctx)){
while($c=fread($fp,8192)){
echo$c
}
fclose($fp)
}
?>
【MySQL】
php中的mysql客户端都没有设置超时的选项，mysqli和mysql都没有，但是libmysql是提供超时选项的，只是我们在php中隐藏了而已。
那么如何在PHP中使用这个 *** 作捏，就需要我们自己定义一些MySQL *** 作常量，主要涉及的常量有：
MYSQL_OPT_READ_TIMEOUT=11
MYSQL_OPT_WRITE_TIMEOUT=12
这两个，定义以后，可以使用options设置相应的值。
不过有个注意点，mysql内部实现：
1.超时设置单位为秒，最少配置1秒
2.但mysql底层的read会重试两次，所以实际会是3秒
重试两次+ 自身一次=3倍超时时间，那么就是说最少超时时间是3秒，不会低于这个值，对于大部分应用来说可以接受，但是对于小部分应用需要优化。
查看一个设置访问mysql超时的php实例：
复制代码 代码如下:
<?php
//自己定义读写超时常量
if(!defined('MYSQL_OPT_READ_TIMEOUT')){
define('MYSQL_OPT_READ_TIMEOUT',11)
}
if(!defined('MYSQL_OPT_WRITE_TIMEOUT')){
define('MYSQL_OPT_WRITE_TIMEOUT',12)
}
//设置超时
$mysqli=mysqli_init()
$mysqli->options(MYSQL_OPT_READ_TIMEOUT,3)
$mysqli->options(MYSQL_OPT_WRITE_TIMEOUT,1)
//连接数据库
$mysqli->real_connect("localhost","root","root","test")
if(mysqli_connect_errno()){
printf("Connectfailed:%s/n",mysqli_connect_error())
exit()
}
//执行查询sleep1秒不超时
printf("Hostinformation:%s/n",$mysqli->host_info)
if(!($res=$mysqli->query('selectsleep(1)'))){
echo"query1error:".$mysqli->error."/n"
}else{
echo"Query1:querysuccess/n"
}
//执行查询sleep9秒会超时
if(!($res=$mysqli->query('selectsleep(9)'))){
echo"query2error:".$mysqli->error."/n"
}else{
echo"Query2:querysuccess/n"
}
$mysqli->close()
echo"closemysqlconnection/n"
?>
延伸阅读：
【Memcached】
[PHP扩展]
php_memcache客户端：
连接超时：boolMemcache::connect(string$host[,int$port[,int$timeout]])
在get和set的时候，都没有明确的超时设置参数。
libmemcached客户端：在php接口没有明显的超时参数。
说明：所以说，在PHP中访问Memcached是存在很多问题的，需要自己hack部分 *** 作，或者是参考网上补丁。
[C&C++访问Memcached]
客户端：libmemcached客户端
说明：memcache超时配置可以配置小点，比如5，10个毫秒已经够用了，超过这个时间还不如从数据库查询。
下面是一个连接和读取set数据的超时的C++示例：
复制代码 代码如下:
//创建连接超时（连接到Memcached）
memcached_st*MemCacheProxy::_create_handle()
{
memcached_st*mmc=NULL
memcached_return_tprc
if(_mpool!=NULL){//getfrompool
mmc=memcached_pool_pop(_mpool,false,&prc)
if(mmc==NULL){
__LOG_WARNING__("MemCacheProxy","gethandlefrompoolerror[%d]",(int)prc)
}
returnmmc
}
memcached_st*handle=memcached_create(NULL)
if(handle==NULL){
__LOG_WARNING__("MemCacheProxy","create_handleerror")
returnNULL
}
//设置连接/读取超时
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_HASH,MEMCACHED_HASH_DEFAULT)
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_NO_BLOCK,_noblock)//参数MEMCACHED_BEHAVIOR_NO_BLOCK为1使超时配置生效，不设置超时会不生效，关键时候会悲剧的，容易引起雪崩
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT,_connect_timeout)//连接超时
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_RCV_TIMEOUT,_read_timeout)//读超时
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_SND_TIMEOUT,_send_timeout)//写超时
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_POLL_TIMEOUT,_poll_timeout)
//设置一致hash
//memcached_behavior_set_distribution(handle,MEMCACHED_DISTRIBUTION_CONSISTENT)
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_DISTRIBUTION,MEMCACHED_DISTRIBUTION_CONSISTENT)
memcached_returnrc
for(uinti=0i<_server_counti++){
rc=memcached_server_add(handle,_ips[i],_ports[i])
if(MEMCACHED_SUCCESS!=rc){
__LOG_WARNING__("MemCacheProxy","addserver[%s:%d]failed.",_ips[i],_ports[i])
}
}
_mpool=memcached_pool_create(handle,_min_connect,_max_connect)
if(_mpool==NULL){
__LOG_WARNING__("MemCacheProxy","create_poolerror")
returnNULL
}
mmc=memcached_pool_pop(_mpool,false,&prc)
if(mmc==NULL){
__LOG_WARNING__("MyMemCacheProxy","gethandlefrompoolerror[%d]",(int)prc)
}
//__LOG_DEBUG__("MemCacheProxy","gethandle[%p]",handle)
returnmmc
}
//设置一个key超时（set一个数据到memcached）
boolMemCacheProxy::_add(memcached_st*handle,unsignedint*key,constchar*value,intlen,unsignedinttimeout)
{
memcached_returnrc
chartmp[1024]
snprintf(tmp,sizeof(tmp),"%u#%u",key[0],key[1])
//有个timeout值
rc=memcached_set(handle,tmp,strlen(tmp),(char*)value,len,timeout,0)
if(MEMCACHED_SUCCESS!=rc){
returnfalse
}
returntrue
}
//Memcache读取数据超时(没有设置)
libmemcahed源码中接口定义：
LIBMEMCACHED_APIchar*memcached_get(memcached_st*ptr,constchar*key,size_tkey_length,size_t*value_length,uint32_t*flags,memcached_return_t*error)
LIBMEMCACHED_APImemcached_return_tmemcached_mget(memcached_st*ptr,constchar*const*keys,constsize_t*key_length,size_tnumber_of_keys)
从接口中可以看出在读取数据的时候，是没有超时设置的。
延伸阅读：
【如何实现超时】
程序中需要有超时这种功能，比如你单独访问一个后端Socket模块，Socket模块不属于我们上面描述的任何一种的时候，它的协议也是私有的，那么这个时候可能需要自己去实现一些超时处理策略，这个时候就需要一些处理代码了。
[PHP中超时实现]
一、初级：最简单的超时实现 （秒级超时）
思路很简单：链接一个后端，然后设置为非阻塞模式，如果没有连接上就一直循环，判断当前时间和超时时间之间的差异。
phpsocket中实现原始的超时：(每次循环都当前时间去减，性能会很差，cpu占用会较高)
复制代码 代码如下:
<?
$host="127.0.0.1"
$port="80"
$timeout=15//timeoutinseconds
$socket=socket_create(AF_INET,SOCK_STREAM,SOL_TCP)
ordie("Unabletocreatesocketn")
socket_set_nonblock($socket) //务必设置为阻塞模式
ordie("Unabletosetnonblockonsocketn")
$time=time()
//循环的时候每次都减去相应值
while(!@socket_connect($socket,$host,$port))//如果没有连接上就一直死循环
{
$err=socket_last_error($socket)
if($err==115||$err==114)
{
if((time()-$time)>=$timeout)//每次都需要去判断一下是否超时了
{
socket_close($socket)
die("Connectiontimedout.n")
}
sleep(1)
continue
}
die(socket_strerror($err)."n")
}
socket_set_block($this->socket)//还原阻塞模式
ordie("Unabletosetblockonsocketn")
?>
二、升级：使用PHP自带异步IO去实现（毫秒级超时）
说明：
异步IO：异步IO的概念和同步IO相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。异步IO将比特分成小组进行传送，小组可以是8位的1个字符或更长。发送方可以在任何时刻发送这些比特组，而接收方从不知道它们会在什么时候到达。
多路复用：复用模型是对多个IO *** 作进行检测，返回可 *** 作集合，这样就可以对其进行 *** 作了。这样就避免了阻塞IO不能随时处理各个IO和非阻塞占用系统资源的确定。
使用socket_select()实现超时
socket_select(...,floor($timeout),ceil($timeout*1000000))
select的特点：能够设置到微秒级别的超时！
使用socket_select()的超时代码（需要了解一些异步IO编程的知识去理解）
复制代码 代码如下:
编程 调用类 编程#
<?php
$server=newServer
$client=newClient
for(){
foreach($select->can_read(0)as$socket){
if($socket==$client->socket){
//NewClientSocket
$select->add(socket_accept($client->socket))
}
else{
//there'ssomethingtoreadon$socket
}
}
}
?>
编程 异步多路复用IO &超时连接处理类 编程
<?php
classselect{
var$sockets
functionselect($sockets){
$this->sockets=array()
foreach($socketsas$socket){
$this->add($socket)
}
}
functionadd($add_socket){
array_push($this->sockets,$add_socket)
}
functionremove($remove_socket){
$sockets=array()
foreach($this->socketsas$socket){
if($remove_socket!=$socket)
$sockets[]=$socket
}
$this->sockets=$sockets
}
functioncan_read($timeout){
$read=$this->sockets
socket_select($read,$write=NULL,$except=NULL,$timeout)
return$read
}
functioncan_write($timeout){
$write=$this->sockets
socket_select($read=NULL,$write,$except=NULL,$timeout)
return$write
}
}
?>
[C&C++中超时实现]
一般在LinuxC/C++中，可以使用：alarm()设置定时器的方式实现秒级超时，或者：select()、poll()、epoll()之类的异步复用IO实现毫秒级超时。也可以使用二次封装的异步io库（libevent,libev）也能实现。
一、使用alarm中用信号实现超时 （秒级超时）
说明：Linux内核connect超时通常为75秒，我们可以设置更小的时间如10秒来提前从connect中返回。这里用使用信号处理机制，调用alarm，超时后产生SIGALRM信号（也可使用select实现）
用alarym秒级实现 connect设置超时代码示例：
复制代码 代码如下:
//信号处理函数
staticvoidconnect_alarm(intsigno)
{
debug_printf("SignalHandler")
return
}
//alarm超时连接实现
staticvoidconn_alarm()
{
Sigfunc*sigfunc//现有信号处理函数
sigfunc=signal(SIGALRM,connect_alarm)//建立信号处理函数connect_alarm,(如果有)保存现有的信号处理函数
inttimeout=5
//设置闹钟
if(alarm(timeout)!=0){
//...闹钟已经设置处理
}
//进行连接 *** 作
if(connect(m_Socket,(structsockaddr*)&addr,sizeof(addr))<0){
if(errno==EINTR){//如果错误号设置为EINTR，说明超时中断了
debug_printf("Timeout")
很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等，需要设置hibernate.cache.provider_class，我们这里用ehcache，在2.1中就是
hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider
如果使用查询缓存，加上
hibernate.cache.use_query_cache=true
缓存可以简单的看成一个Map，通过key在缓存里面找value。
Class的缓存
对于一条记录，也就是一个PO来说，是根据ID来找的，缓存的key就是ID，value是POJO。无论list，load还是iterate，只要读出一个对象，都会填充缓存。但是list不会使用缓存，而iterate会先取数据库select id出来，然后一个id一个id的load，如果在缓存里面有，就从缓存取，没有的话就去数据库load。假设是读写缓存，需要设置：
<cache usage="read-write"/>
如果你使用的二级缓存实现是ehcache的话，需要配置ehcache.xml
<cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
其中eternal表示缓存是不是永远不超时，timeToLiveSeconds是缓存中每个元素（这里也就是一个POJO）的超时时间，如果eternal="false"，超过指定的时间，这个元素就被移走了。timeToIdleSeconds是发呆时间，是可选的。当往缓存里面put的元素超过500个时，如果overflowToDisk="true"，就会把缓存中的部分数据保存在硬盘上的临时文件里面。
每个需要缓存的class都要这样配置。如果你没有配置，hibernate会在启动的时候警告你，然后使用defaultCache的配置，这样多个class会共享一个配置。
当某个ID通过hibernate修改时，hibernate会知道，于是移除缓存。
这样大家可能会想，同样的查询条件，第一次先list，第二次再iterate，就可以使用到缓存了。实际上这是很难的，因为你无法判断什么时候是第一次，而且每次查询的条件通常是不一样的，假如数据库里面有100条记录，id从1到100，第一次list的时候出了前50个id，第二次iterate的时候却查询到30至70号id，那么30-50是从缓存里面取的，51到70是从数据库取的，共发送1+20条sql。所以我一直认为iterate没有什么用，总是会有1+N的问题。
（题外话：有说法说大型查询用list会把整个结果集装入内存，很慢，而iterate只select id比较好，但是大型查询总是要分页查的，谁也不会真的把整个结果集装进来，假如一页20条的话，iterate共需要执行21条语句，list虽然选择若干字段，比iterate第一条select id语句慢一些，但只有一条语句，不装入整个结果集hibernate还会根据数据库方言做优化，比如使用mysql的limit，整体看来应该还是list快。）
如果想要对list或者iterate查询的结果缓存，就要用到查询缓存了
查询缓存
首先需要配置hibernate.cache.use_query_cache=true
如果用ehcache，配置ehcache.xml，注意hibernate3.0以后不是net.sf的包名了
<cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/>
<cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
然后
query.setCacheable(true)//激活查询缓存
query.setCacheRegion("myCacheRegion")//指定要使用的cacheRegion，可选
第二行指定要使用的cacheRegion是myCacheRegion，即你可以给每个查询缓存做一个单独的配置，使用setCacheRegion来做这个指定，需要在ehcache.xml里面配置它：
<cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />
如果省略第二行，不设置cacheRegion的话，那么会使用上面提到的标准查询缓存的配置，也就是net.sf.hibernate.cache.StandardQueryCache
对于查询缓存来说，缓存的key是根据hql生成的sql，再加上参数，分页等信息（可以通过日志输出看到，不过它的输出不是很可读，最好改一下它的代码）。
比如hql：
from Cat c where c.name like ?
生成大致如下的sql：
select * from cat c where c.name like ?
参数是"tiger%"，那么查询缓存的key*大约*是这样的字符串（我是凭记忆写的，并不精确，不过看了也该明白了）：
select * from cat c where c.name like ? , parameter:tiger%
这样，保证了同样的查询、同样的参数等条件下具有一样的key。
现在说说缓存的value，如果是list方式的话，value在这里并不是整个结果集，而是查询出来的这一串ID。也就是说，不管是list方法还是iterate方法，第一次查询的时候，它们的查询方式很它们平时的方式是一样的，list执行一条sql，iterate执行1+N条，多出来的行为是它们填充了缓存。但是到同样条件第二次查询的时候，就都和iterate的行为一样了，根据缓存的key去缓存里面查到了value，value是一串id，然后在到class的缓存里面去一个一个的load出来。这样做是为了节约内存。
可以看出来，查询缓存需要打开相关类的class缓存。list和iterate方法第一次执行的时候，都是既填充查询缓存又填充class缓存的。
这里还有一个很容易被忽视的重要问题，即打开查询缓存以后，即使是list方法也可能遇到1+N的问题！相同条件第一次list的时候，因为查询缓存中找不到，不管class缓存是否存在数据，总是发送一条sql语句到数据库获取全部数据，然后填充查询缓存和class缓存。但是第二次执行的时候，问题就来了，如果你的class缓存的超时时间比较短，现在class缓存都超时了，但是查询缓存还在，那么list方法在获取id串以后，将会一个一个去数据库load！因此，class缓存的超时时间一定不能短于查询缓存设置的超时时间！如果还设置了发呆时间的话，保证class缓存的发呆时间也大于查询的缓存的生存时间。这里还有其他情况，比如class缓存被程序强制evict了，这种情况就请自己注意了。
另外，如果hql查询包含select字句，那么查询缓存里面的value就是整个结果集了。
当hibernate更新数据库的时候，它怎么知道更新哪些查询缓存呢？
hibernate在一个地方维护每个表的最后更新时间，其实也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的缓存配置里面。
当通过hibernate更新的时候，hibernate会知道这次更新影响了哪些表。然后它更新这些表的最后更新时间。每个缓存都有一个生成时间和这个缓存所查询的表，当hibernate查询一个缓存是否存在的时候，如果缓存存在，它还要取出缓存的生成时间和这个缓存所查询的表，然后去查找这些表的最后更新时间，如果有一个表在生成时间后更新过了，那么这个缓存是无效的。
可以看出，只要更新过一个表，那么凡是涉及到这个表的查询缓存就失效了，因此查询缓存的命中率可能会比较低。
Collection缓存
需要在hbm的collection里面设置
<cache usage="read-write"/>
假如class是Cat，collection叫children，那么ehcache里面配置
<cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" />
Collection的缓存和前面查询缓存的list一样，也是只保持一串id，但它不会因为这个表更新过就失效，一个collection缓存仅在这个collection里面的元素有增删时才失效。
这样有一个问题，如果你的collection是根据某个字段排序的，当其中一个元素更新了该字段时，导致顺序改变时，collection缓存里面的顺序没有做更新。
缓存策略
只读缓存（read-only）：没有什么好说的
读/写缓存（read-write）:程序可能要的更新数据
不严格的读/写缓存（nonstrict-read-write）：需要更新数据，但是两个事务更新同一条记录的可能性很小，性能比读写缓存好
事务缓存（transactional）：缓存支持事务，发生异常的时候，缓存也能够回滚，只支持jta环境，这个我没有怎么研究过
读写缓存和不严格读写缓存在实现上的区别在于，读写缓存更新缓存的时候会把缓存里面的数据换成一个锁，其他事务如果去取相应的缓存数据，发现被锁住了，然后就直接取数据库查询。
在hibernate2.1的ehcache实现中，如果锁住部分缓存的事务发生了异常，那么缓存会一直被锁住，直到60秒后超时。
不严格读写缓存不锁定缓存中的数据。
使用二级缓存的前置条件
你的hibernate程序对数据库有独占的写访问权，其他的进程更新了数据库，hibernate是不可能知道的。你 *** 作数据库必需直接通过hibernate，如果你调用存储过程，或者自己使用jdbc更新数据库，hibernate也是不知道的。hibernate3.0的大批量更新和删除是不更新二级缓存的，但是据说3.1已经解决了这个问题。
这个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧。
SessionFactory也提供了移除缓存的方法，你一定要自己写一些JDBC的话，可以调用这些方法移除缓存，这些方法是：
void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.
不过我不建议这样做，因为这样很难维护。比如你现在用JDBC批量更新了某个表，有3个查询缓存会用到这个表，用evictQueries(String cacheRegion)移除了3个查询缓存，然后用evict(Class persistentClass)移除了class缓存，看上去好像完整了。不过哪天你添加了一个相关查询缓存，可能会忘记更新这里的移除代码。如果你的jdbc代码到处都是，在你添加一个查询缓存的时候，还知道其他什么地方也要做相应的改动吗？
----------------------------------------------------
总结：
不要想当然的以为缓存一定能提高性能，仅仅在你能够驾驭它并且条件合适的情况下才是这样的。hibernate的二级缓存限制还是比较多的，不方便用jdbc可能会大大的降低更新性能。在不了解原理的情况下乱用，可能会有1+N的问题。不当的使用还可能导致读出脏数据。
如果受不了hibernate的诸多限制，那么还是自己在应用程序的层面上做缓存吧。
在越高的层面上做缓存，效果就会越好。就好像尽管磁盘有缓存，数据库还是要实现自己的缓存，尽管数据库有缓存，咱们的应用程序还是要做缓存。因为底层的缓存它并不知道高层要用这些数据干什么，只能做的比较通用，而高层可以有针对性的实现缓存，所以在更高的级别上做缓存，效果也要好些吧。
终于写完了，好累……
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）