SOA宣称的一大优势是异构系统服务整合,最大化利用现有的，旧系统的功能。
但怎么热论的都是B/S结构的，基于WebService的系统之间的SOA解决方案呢？甚至大多都是基于java的，也有.net和java之间的，但这有什么稀奇的呢？ 在SOA这个概念出来之前， B/s结构的系统之间通信，整合方法本来就很多（http,xml,soap,webservice等等），SOA只不过把这些方法归拢，并形成一个标准的模式，也即包装而已。当然SOA提出的构建系统的理念还是很值得吸取的。
问题在由，SOA强调的它最大的功能就是，异构，任何语言编写的，新的，旧的系统之间都能共享服务，数据。
那么如果是3个旧的系统(C/S结构的)，分别用vb, delphi, c++ 或者其它任何语言编写的系统之间，如何通过应用SOA来让这三个旧的系统协同工作，服务，流程，数据共享呢？ 如果有办法，那是否需要花费大量的时间对这些系统进行重新开发呢？
如果没有办法，或有办法太花费的代价太大，那是不是可以说，能够应用SOA这个概念进行整合的系统，其开发时必须遵守SOA的标准规范呢？ 如果不遵守，将不能应用SOA, 或者说将付出很大的代价才能SOA. 那这对于那些想整合共享异构的老系统的服务的用户来说还有什么意义呢？ SOA的“充分发挥,利用legacy system 服务”的这一优势又如何体现呢？
以或这里的legacy system是指的不能太老？ 至少能支持web service的?
也就是说，不是任何系统的改造都能套用SOA的，但是SOA的概念里面可是说的任何系统，所有语言啊，这可是让很多客户为止狂欢的主要原因啊
B/S基本都是通过web service来干的吧？
像LZ这样几个C/S来搞SOA的，以前还真没想过。如果是不同的语言编写的话又要协同，应该要使用一种通用的数据格式了，最直接的大概是XML吧，那不又像WS一样了？
期待高人的想法出现
是啊，我们给客户吹了半天SOA，人家很感兴趣。但人家的系统都是C/S的老系统，而且用的很好，不愿意重新开发新的，只是希望能在这几个旧系统里做整合。
怎么做？ 到处宣扬平台，语言无关性，但到处讨论的都是有局限性的，基于java, .net的应用。
遇到这种老式语言开发的C/S系统怎么应用呢？ 会不会经过调研，预算后得出结论:在这种结构上应用SOA代价过大，因此SOA不适用！那就又和SOA的最亮点冲突了。
期待指点，谢谢！
SOA只是个名词，落到实处，异构应用的整合问题，也就是要让说不同语言的人之间能够交流，本来就没有什么灵丹妙药，只能设定出一个世界语让大家来通用。妄想扔个SOA锦囊进去，世界就马上大同了，这是天方夜谭，呵呵。
好像SOA不是一种技术吧,在我看来SOA是一种态度. 以前老的系统怎么样了.如果跑的很好又何必重新开发呢?你要做的只是把老的系统提供的功能适配成你的SOA平台能够识别的服务.
“把老的系统提供的功能适配成你的SOA平台能够识别的服务” 这句话是核心。但是怎么做呢？ 我想用一些传统的，老套的办法也可能解决问题，但这是不是SOA呢？ 怎么做才算的上是正宗的SOA呢。
还是SOA说了"只要你整合，共享服务了，就都属于我SOA了”
太过强调SOA的概念。其实客户关心的是如何整合原来老的系统，共享数据，提高效率。是否采用SOA和如何采用SOA不是他们关心的事情。抓住事情的本质
SOA确实就是个大忽悠，没有它之前异构系统的整合的案例照样存在，而且实施的很好
如果把SOA理解成技术，首先看SCA的C++版能不能很容易的封装旧代码，如果不能，就直接考虑数据级别的整合吧，你们可以针对数据库开发一个web service的应用然后和SOA平台进行整合
SOA的目的就是为了整合老应用系统，实现数据交互，并且，最重要的，减少耦合，降低二次开发量。
讨论少的原因是，这里许多人没有（VC，带耳非，VB）等工作经验，也没用过。怎么交流？而且，每本书上，每个人都在谈C/S维护难的问题，自然没人愿意去趟这浑水。
SOA其实也是要解决新系统和老系统的互联问题。 当然还是得通过web services. 用JBI举例， 对老的C/S结构的系统， 你需要开发一个BC作为老系统的web services接口和其他系统通信， 同时这个BC也是老系统的一个Client。这也是为什么会有很多JDBC, File, SMTP等等BC的原因
不同意这个说法,SOA不一定要通过WS 通过WS的SOA我觉得很危险,不论你是内部路由调度还是服务发布用WS接口 后期性能都将极其的低.特别是内部路由这块,服务发布用ws倒是可以考虑. 在SOA平台内部建议使用长连接去进行通信. 根据我的测试结果 简单一个报文在短连接的情况下 要比长连接的情况最少慢一个到两个数量级. 而且SOA是不暴露WS的 他暴露的仅仅是一个访问接入的接入点(服务的协议发布形式是不暴露的).应用统一通过这个接入点接入到SOA平台内,如果你直接暴露服务的协议那这个平台缺少安全性和规范性.
SOA是概念， 集成构架， 而JBI是一种实现SOA的技术。两个是不同层次的东西。 JBI是要求用SOAP进行通信， 但SOA完全可以不基于Web services, 更何况SOAP。
SOA是不暴露WS的： 我觉得SOA是一种理念， 只有一个应用才有暴露WS的问题。
至于性能，你的BC可以保持长连接， 但ESB内部还是通过消息传递（都不一定是IPC）， 这也是在实施时考虑的具体优化问题
SOA是概念， 集成构架， 而JBI是一种实现SOA的技术。两个是不同层次的东西。 JBI是要求用SOAP进行通信， 但SOA完全可以不基于Web services, 更何况SOAP。
SOA是不暴露WS的： 我觉得SOA是一种理念， 只有一个应用才有暴露WS的问题。
至于性能，你的BC可以保持长连接， 但ESB内部还是通过消息传递（都不一定是IPC）， 这也是在实施时考虑的具体优化问题。
RMI也可以实现SOA的，前面很多人说过，SOA只是一种架构方式.
但怎么热论的都是B/S结构的，基于WebService的系统之间的SOA解决方案呢？甚至大多都是基于java的，也有.net和java之间的，但这有什么稀奇的呢？ 在SOA这个概念出来之前， B/s结构的系统之间通信，整合方法本来就很多（http,xml,soap,webservice等等），SOA只不过把这些方法归拢，并形成一个标准的模式，也即包装而已。当然SOA提出的构建系统的理念还是很值得吸取的。
问题在由，SOA强调的它最大的功能就是，异构，任何语言编写的，新的，旧的系统之间都能共享服务，数据。
那么如果是3个旧的系统(C/S结构的)，分别用vb, delphi, c++ 或者其它任何语言编写的系统之间，如何通过应用SOA来让这三个旧的系统协同工作，服务，流程，数据共享呢？ 如果有办法，那是否需要花费大量的时间对这些系统进行重新开发呢？
如果没有办法，或有办法太花费的代价太大，那是不是可以说，能够应用SOA这个概念进行整合的系统，其开发时必须遵守SOA的标准规范呢？ 如果不遵守，将不能应用SOA, 或者说将付出很大的代价才能SOA. 那这对于那些想整合共享异构的老系统的服务的用户来说还有什么意义呢？ SOA的“充分发挥,利用legacy system 服务”的这一优势又如何体现呢？
以或这里的legacy system是指的不能太老？ 至少能支持web service的?
也就是说，不是任何系统的改造都能套用SOA的，但是SOA的概念里面可是说的任何系统，所有语言啊，这可是让很多客户为止狂欢的主要原因啊
B/S基本都是通过web service来干的吧？
像LZ这样几个C/S来搞SOA的，以前还真没想过。如果是不同的语言编写的话又要协同，应该要使用一种通用的数据格式了，最直接的大概是XML吧，那不又像WS一样了？
期待高人的想法出现
是啊，我们给客户吹了半天SOA，人家很感兴趣。但人家的系统都是C/S的老系统，而且用的很好，不愿意重新开发新的，只是希望能在这几个旧系统里做整合。
怎么做？ 到处宣扬平台，语言无关性，但到处讨论的都是有局限性的，基于java, .net的应用。
遇到这种老式语言开发的C/S系统怎么应用呢？ 会不会经过调研，预算后得出结论:在这种结构上应用SOA代价过大，因此SOA不适用！那就又和SOA的最亮点冲突了。
期待指点，谢谢！
SOA只是个名词，落到实处，异构应用的整合问题，也就是要让说不同语言的人之间能够交流，本来就没有什么灵丹妙药，只能设定出一个世界语让大家来通用。妄想扔个SOA锦囊进去，世界就马上大同了，这是天方夜谭，呵呵。
好像SOA不是一种技术吧,在我看来SOA是一种态度. 以前老的系统怎么样了.如果跑的很好又何必重新开发呢?你要做的只是把老的系统提供的功能适配成你的SOA平台能够识别的服务.
“把老的系统提供的功能适配成你的SOA平台能够识别的服务” 这句话是核心。但是怎么做呢？ 我想用一些传统的，老套的办法也可能解决问题，但这是不是SOA呢？ 怎么做才算的上是正宗的SOA呢。
还是SOA说了"只要你整合，共享服务了，就都属于我SOA了”
太过强调SOA的概念。其实客户关心的是如何整合原来老的系统，共享数据，提高效率。是否采用SOA和如何采用SOA不是他们关心的事情。抓住事情的本质
SOA确实就是个大忽悠，没有它之前异构系统的整合的案例照样存在，而且实施的很好
如果把SOA理解成技术，首先看SCA的C++版能不能很容易的封装旧代码，如果不能，就直接考虑数据级别的整合吧，你们可以针对数据库开发一个web service的应用然后和SOA平台进行整合
SOA的目的就是为了整合老应用系统，实现数据交互，并且，最重要的，减少耦合，降低二次开发量。
讨论少的原因是，这里许多人没有（VC，带耳非，VB）等工作经验，也没用过。怎么交流？而且，每本书上，每个人都在谈C/S维护难的问题，自然没人愿意去趟这浑水。
SOA其实也是要解决新系统和老系统的互联问题。 当然还是得通过web services. 用JBI举例， 对老的C/S结构的系统， 你需要开发一个BC作为老系统的web services接口和其他系统通信， 同时这个BC也是老系统的一个Client。这也是为什么会有很多JDBC, File, SMTP等等BC的原因
不同意这个说法,SOA不一定要通过WS 通过WS的SOA我觉得很危险,不论你是内部路由调度还是服务发布用WS接口 后期性能都将极其的低.特别是内部路由这块,服务发布用ws倒是可以考虑. 在SOA平台内部建议使用长连接去进行通信. 根据我的测试结果 简单一个报文在短连接的情况下 要比长连接的情况最少慢一个到两个数量级. 而且SOA是不暴露WS的 他暴露的仅仅是一个访问接入的接入点(服务的协议发布形式是不暴露的).应用统一通过这个接入点接入到SOA平台内,如果你直接暴露服务的协议那这个平台缺少安全性和规范性.
SOA是概念， 集成构架， 而JBI是一种实现SOA的技术。两个是不同层次的东西。 JBI是要求用SOAP进行通信， 但SOA完全可以不基于Web services, 更何况SOAP。
SOA是不暴露WS的： 我觉得SOA是一种理念， 只有一个应用才有暴露WS的问题。
至于性能，你的BC可以保持长连接， 但ESB内部还是通过消息传递（都不一定是IPC）， 这也是在实施时考虑的具体优化问题
SOA是概念， 集成构架， 而JBI是一种实现SOA的技术。两个是不同层次的东西。 JBI是要求用SOAP进行通信， 但SOA完全可以不基于Web services, 更何况SOAP。
SOA是不暴露WS的： 我觉得SOA是一种理念， 只有一个应用才有暴露WS的问题。
至于性能，你的BC可以保持长连接， 但ESB内部还是通过消息传递（都不一定是IPC）， 这也是在实施时考虑的具体优化问题。
RMI也可以实现SOA的，前面很多人说过，SOA只是一种架构方式.
金山词霸2009与我的linux secure操作快捷键冲突 
Php/Js/Shell/Go jackxiang 2010-1-7 11:12
兄弟我经常需要用到bash 的好用的快捷键，ctrl+l:清屏，相当于clear。
装了个金山词霸（当然盗版啦），发现ctrl+l:清屏没有用了，于是在软件设置里面有个朗读的快捷键也是ctrl+l，去掉了就ok了。嘻嘻
装了个金山词霸（当然盗版啦），发现ctrl+l:清屏没有用了，于是在软件设置里面有个朗读的快捷键也是ctrl+l，去掉了就ok了。嘻嘻
命令重定向:
在Bash命令执行中,除了有>符号,还有3种输出输入状况,分别是:
1 标准输入: 代码为0,或称为stdin,使用方式为<
2 标准输出: 代码为1,或称为stdout,使用方式为1>
3 错误输出: 代码为2,或称为stderr,使用方式为2>
>> 累加到文件中,文件累加,旧数据保留.
例:
[test @test test]# ls –al 1>list.txt 2>list.err
将显示数据正确输出到list.txt,错误的数据输出到list.err
>与>>比较,区别:
>: 将原来由屏幕输出的正确数据输出到>右边的文件或设备
>>: 将原来由屏幕输出的正确数据输出到>>右边,与>不同的是,该文件将不会被覆盖,而新的数据将以累加方式添加到文件的最后面.
/dev/null是什么呢?
答: 基本上,它有点象一个无底洞,专门收集垃圾,当您输入的任何东西导向到这个虚拟的垃圾桶,它就会凭空消失,非常有用.
例:
[test @test test]# find /-name testing 1> list_right 2> /dev/null
如果要把数据都写到同一个文件中
[test @test test]# find /-name testing 1> list_right 2>&1
管线命令
管线命令使用的是”|”界定符号
管线命令”|”仅能处理经由前一个指令传来的正确信息,也就是标准输出(stdout)信息,对于标准错误信息并没有直接处理能力.
每个管线部分都是指令,而后一个指令的输入乃是前一个指令的输出.
常用的管线命令:
cut
语法:
[root @test /root]# cut –d “分隔字符” [-cf] fields
参数说明:
-d: 后面接的是分割字符,默认是空格符
-c: 后面接的是第几个字符
-f: 后面接的是第几个区块
cut的主要用途在于将同一行里的数据进行分解,最常用在分析一些数据或文件数据的时候,因为有时候我们会以某些字符当作分割参数,然后将数据加以切割,以取得我们需要的数据(常用与分析我们的日志文件).
sort
语法:
[root @test /root]# sort [-t 分隔符] [(+起始)(-结束)][-nru]
参数说明:
-t 分隔符: 使用分隔符隔开不同区块,默认是tab
+start –end: 由第start区块排序到end区块
-n: 使用纯数字排序(否则会以字母方式排序)
-r: 反向排序
-u: 相同出现的一行,只列出一次
[root @test /root]# cat /etc/passwd | sort
将列出来的个人帐号排序
wc
语法:
[root @test /root]# wc [-lmw]
参数说明:
-l: 多少行
-m: 多少符号
-w: 多少字
例:
[root @test /root]# cat /etc/passwd | wc –l
这个文件里有多少行.
uniq
语法:
[root @test /root]#uniq
uniq删除重复的行从而只显示一个
tee
例:
[root @test /root]# last | tee last.list | cut –d “ ” –fi
使用tee,会将数据同时传给下一个命令执行,也会将数据写入last.list文件中
tr
语法:
[root @test /root]# tr [-ds] SET1
参数说明:
-d: 删除SET1这个字符串
-s: 取代重复的字符
例:
[root @test /root]# cat /etc/passwd | tr –d:
“:”这个符号在/etc/passwd中不见了
split
语法:
[root @test /root]# split [bl] 输入文件 输出文件前导字符
参数说明:
-b: 以文件SIZE来分
-l: 以行数来分
例:
[root @test /root]# split –l 5 /etc/passwd test
会产生testaa,testab,testac等文件
在Bash命令执行中,除了有>符号,还有3种输出输入状况,分别是:
1 标准输入: 代码为0,或称为stdin,使用方式为<
2 标准输出: 代码为1,或称为stdout,使用方式为1>
3 错误输出: 代码为2,或称为stderr,使用方式为2>
>> 累加到文件中,文件累加,旧数据保留.
例:
[test @test test]# ls –al 1>list.txt 2>list.err
将显示数据正确输出到list.txt,错误的数据输出到list.err
>与>>比较,区别:
>: 将原来由屏幕输出的正确数据输出到>右边的文件或设备
>>: 将原来由屏幕输出的正确数据输出到>>右边,与>不同的是,该文件将不会被覆盖,而新的数据将以累加方式添加到文件的最后面.
/dev/null是什么呢?
答: 基本上,它有点象一个无底洞,专门收集垃圾,当您输入的任何东西导向到这个虚拟的垃圾桶,它就会凭空消失,非常有用.
例:
[test @test test]# find /-name testing 1> list_right 2> /dev/null
如果要把数据都写到同一个文件中
[test @test test]# find /-name testing 1> list_right 2>&1
管线命令
管线命令使用的是”|”界定符号
管线命令”|”仅能处理经由前一个指令传来的正确信息,也就是标准输出(stdout)信息,对于标准错误信息并没有直接处理能力.
每个管线部分都是指令,而后一个指令的输入乃是前一个指令的输出.
常用的管线命令:
cut
语法:
[root @test /root]# cut –d “分隔字符” [-cf] fields
参数说明:
-d: 后面接的是分割字符,默认是空格符
-c: 后面接的是第几个字符
-f: 后面接的是第几个区块
cut的主要用途在于将同一行里的数据进行分解,最常用在分析一些数据或文件数据的时候,因为有时候我们会以某些字符当作分割参数,然后将数据加以切割,以取得我们需要的数据(常用与分析我们的日志文件).
sort
语法:
[root @test /root]# sort [-t 分隔符] [(+起始)(-结束)][-nru]
参数说明:
-t 分隔符: 使用分隔符隔开不同区块,默认是tab
+start –end: 由第start区块排序到end区块
-n: 使用纯数字排序(否则会以字母方式排序)
-r: 反向排序
-u: 相同出现的一行,只列出一次
[root @test /root]# cat /etc/passwd | sort
将列出来的个人帐号排序
wc
语法:
[root @test /root]# wc [-lmw]
参数说明:
-l: 多少行
-m: 多少符号
-w: 多少字
例:
[root @test /root]# cat /etc/passwd | wc –l
这个文件里有多少行.
uniq
语法:
[root @test /root]#uniq
uniq删除重复的行从而只显示一个
tee
例:
[root @test /root]# last | tee last.list | cut –d “ ” –fi
使用tee,会将数据同时传给下一个命令执行,也会将数据写入last.list文件中
tr
语法:
[root @test /root]# tr [-ds] SET1
参数说明:
-d: 删除SET1这个字符串
-s: 取代重复的字符
例:
[root @test /root]# cat /etc/passwd | tr –d:
“:”这个符号在/etc/passwd中不见了
split
语法:
[root @test /root]# split [bl] 输入文件 输出文件前导字符
参数说明:
-b: 以文件SIZE来分
-l: 以行数来分
例:
[root @test /root]# split –l 5 /etc/passwd test
会产生testaa,testab,testac等文件
curl_close — 关闭一个curl会话
curl_copy_handle — 拷贝一个curl连接资源的所有内容和参数
curl_errno — 返回一个包含当前会话错误信息的数字编号
curl_error — 返回一个包含当前会话错误信息的字符串
curl_exec — 执行一个curl会话
curl_getinfo — 获取一个curl连接资源句柄的信息
curl_init — 初始化一个curl会话
curl_multi_add_handle — 向curl批处理会话中添加单独的curl句柄资源
curl_multi_close — 关闭一个批处理句柄资源
curl_multi_exec — 解析一个curl批处理句柄
curl_multi_getcontent — 返回获取的输出的文本流
curl_multi_info_read — 获取当前解析的curl的相关传输信息
curl_multi_init — 初始化一个curl批处理句柄资源
curl_multi_remove_handle — 移除curl批处理句柄资源中的某个句柄资源
curl_multi_select — Get all the sockets associated with the cURL extension, which can then be "selected"
curl_setopt_array — 以数组的形式为一个curl设置会话参数
curl_setopt — 为一个curl设置会话参数
curl_version — 获取curl相关的版本信息
curl_init()函数的作用初始化一个curl会话，curl_init()函数唯一的一个参数是可选的，表示一个url地址。
curl_exec()函数的作用是执行一个curl会话，唯一的参数是curl_init()函数返回的句柄。
curl_close()函数的作用是关闭一个curl会话，唯一的参数是curl_init()函数返回的句柄。
<?php
$ch = curl_init("http://www.baidu.com/");
curl_exec($ch);
curl_close($ch);
?>
curl_version()函数的作用是获取curl相关的版本信息，curl_version()函数有一个参数，不清楚是做什么的
<?php
print_r(curl_version())
?>
curl_getinfo()函数的作用是获取一个curl连接资源句柄的信息，curl_getinfo()函数有两个参数，第一个参数是curl的资源句柄，第二个参数是下面一些常量：
<?php
$ch = curl_init("http://www.baidu.com/");
print_r(curl_getinfo($ch));
?>
可选的常量包括：
CURLINFO_EFFECTIVE_URL
最后一个有效的url地址
CURLINFO_HTTP_CODE
最后一个收到的HTTP代码
CURLINFO_FILETIME
远程获取文档的时间，如果无法获取，则返回值为“-1”
CURLINFO_TOTAL_TIME
最后一次传输所消耗的时间
CURLINFO_NAMELOOKUP_TIME
名称解析所消耗的时间
CURLINFO_CONNECT_TIME
建立连接所消耗的时间
CURLINFO_PRETRANSFER_TIME
从建立连接到准备传输所使用的时间
CURLINFO_STARTTRANSFER_TIME
从建立连接到传输开始所使用的时间
CURLINFO_REDIRECT_TIME
在事务传输开始前重定向所使用的时间
CURLINFO_SIZE_UPLOAD
上传数据量的总值
CURLINFO_SIZE_DOWNLOAD
下载数据量的总值
CURLINFO_SPEED_DOWNLOAD
平均下载速度
CURLINFO_SPEED_UPLOAD
平均上传速度
CURLINFO_HEADER_SIZE
header部分的大小
CURLINFO_HEADER_OUT
发送请求的字符串
CURLINFO_REQUEST_SIZE
在HTTP请求中有问题的请求的大小
CURLINFO_SSL_VERIFYRESULT
Result of SSL certification verification requested by setting CURLOPT_SSL_VERIFYPEER
CURLINFO_CONTENT_LENGTH_DOWNLOAD
从Content-Length: field中读取的下载内容长度
CURLINFO_CONTENT_LENGTH_UPLOAD
上传内容大小的说明
CURLINFO_CONTENT_TYPE
下载内容的“Content-type”值，NULL表示服务器没有发送有效的“Content-Type: header”
curl_setopt()函数的作用是为一个curl设置会话参数。curl_setopt_array()函数的作用是以数组的形式为一个curl设置会话参数。
<?php
$ch = curl_init();
$fp = fopen("example_homepage.txt", "w");
curl_setopt($ch, CURLOPT_FILE, $fp);
$options = array(
CURLOPT_URL => 'http://www.baidu.com/',
CURLOPT_HEADER => false
);
curl_setopt_array($ch, $options);
curl_exec($ch);
curl_close($ch);
fclose($fp);
?>
本文来自: 脚本之家(www.jb51.net) 详细出处参考：http://www.jb51.net/article/16224.htm
curl_copy_handle — 拷贝一个curl连接资源的所有内容和参数
curl_errno — 返回一个包含当前会话错误信息的数字编号
curl_error — 返回一个包含当前会话错误信息的字符串
curl_exec — 执行一个curl会话
curl_getinfo — 获取一个curl连接资源句柄的信息
curl_init — 初始化一个curl会话
curl_multi_add_handle — 向curl批处理会话中添加单独的curl句柄资源
curl_multi_close — 关闭一个批处理句柄资源
curl_multi_exec — 解析一个curl批处理句柄
curl_multi_getcontent — 返回获取的输出的文本流
curl_multi_info_read — 获取当前解析的curl的相关传输信息
curl_multi_init — 初始化一个curl批处理句柄资源
curl_multi_remove_handle — 移除curl批处理句柄资源中的某个句柄资源
curl_multi_select — Get all the sockets associated with the cURL extension, which can then be "selected"
curl_setopt_array — 以数组的形式为一个curl设置会话参数
curl_setopt — 为一个curl设置会话参数
curl_version — 获取curl相关的版本信息
curl_init()函数的作用初始化一个curl会话，curl_init()函数唯一的一个参数是可选的，表示一个url地址。
curl_exec()函数的作用是执行一个curl会话，唯一的参数是curl_init()函数返回的句柄。
curl_close()函数的作用是关闭一个curl会话，唯一的参数是curl_init()函数返回的句柄。
<?php
$ch = curl_init("http://www.baidu.com/");
curl_exec($ch);
curl_close($ch);
?>
curl_version()函数的作用是获取curl相关的版本信息，curl_version()函数有一个参数，不清楚是做什么的
<?php
print_r(curl_version())
?>
curl_getinfo()函数的作用是获取一个curl连接资源句柄的信息，curl_getinfo()函数有两个参数，第一个参数是curl的资源句柄，第二个参数是下面一些常量：
<?php
$ch = curl_init("http://www.baidu.com/");
print_r(curl_getinfo($ch));
?>
可选的常量包括：
CURLINFO_EFFECTIVE_URL
最后一个有效的url地址
CURLINFO_HTTP_CODE
最后一个收到的HTTP代码
CURLINFO_FILETIME
远程获取文档的时间，如果无法获取，则返回值为“-1”
CURLINFO_TOTAL_TIME
最后一次传输所消耗的时间
CURLINFO_NAMELOOKUP_TIME
名称解析所消耗的时间
CURLINFO_CONNECT_TIME
建立连接所消耗的时间
CURLINFO_PRETRANSFER_TIME
从建立连接到准备传输所使用的时间
CURLINFO_STARTTRANSFER_TIME
从建立连接到传输开始所使用的时间
CURLINFO_REDIRECT_TIME
在事务传输开始前重定向所使用的时间
CURLINFO_SIZE_UPLOAD
上传数据量的总值
CURLINFO_SIZE_DOWNLOAD
下载数据量的总值
CURLINFO_SPEED_DOWNLOAD
平均下载速度
CURLINFO_SPEED_UPLOAD
平均上传速度
CURLINFO_HEADER_SIZE
header部分的大小
CURLINFO_HEADER_OUT
发送请求的字符串
CURLINFO_REQUEST_SIZE
在HTTP请求中有问题的请求的大小
CURLINFO_SSL_VERIFYRESULT
Result of SSL certification verification requested by setting CURLOPT_SSL_VERIFYPEER
CURLINFO_CONTENT_LENGTH_DOWNLOAD
从Content-Length: field中读取的下载内容长度
CURLINFO_CONTENT_LENGTH_UPLOAD
上传内容大小的说明
CURLINFO_CONTENT_TYPE
下载内容的“Content-type”值，NULL表示服务器没有发送有效的“Content-Type: header”
curl_setopt()函数的作用是为一个curl设置会话参数。curl_setopt_array()函数的作用是以数组的形式为一个curl设置会话参数。
<?php
$ch = curl_init();
$fp = fopen("example_homepage.txt", "w");
curl_setopt($ch, CURLOPT_FILE, $fp);
$options = array(
CURLOPT_URL => 'http://www.baidu.com/',
CURLOPT_HEADER => false
);
curl_setopt_array($ch, $options);
curl_exec($ch);
curl_close($ch);
fclose($fp);
?>
本文来自: 脚本之家(www.jb51.net) 详细出处参考：http://www.jb51.net/article/16224.htm
这次是Fotolog的经验，传说中比Flickr更大的网站，Fotolog在21台服务器上部署了51个memcached实例，总计有254G缓存空间可用，缓存了多达175G的内容，这个数量比很多网站的数据库都要大的多，原文是A Bunch of Great Strategies for Using Memcached and MySQL Better Together，我这里还是选择性的翻译以及按照我的理解补充，感谢Todd Hoff，总能给我们一些学习的案例，从这里也能看出国外技术的开放态度，不似我们，其实就那么点小九九还藏着掖着，好了，进入正题。
一、关于memcached
还不知道这个？那你去面试的时候要吃亏了，赶紧去官方网站看一下http://www.danga.com/memcached/，另外google一下用法，硬盘总是太慢，把数据存在内存里面吧，如果你只有一台服务器，推荐用一下APC(Facebook在用)或者eaccelerator或者Xcache(国人开发的)，这些产品单机效果更好，如果你需要分布式的缓存方案，那么用memcached吧。
二、memcached如何与mysql并肩作战？
* 通过数据库分片来解决数据库写扩展的问题把数据库分片，部署到不同的服务器上，免得只有一个主服务器，写操作成为瓶颈以及可能有的“单点故障”，一般的数据库分片主要是按照业务来分，尽可能的拆分业务，不相干的都独立起来做成服务也好
* 前端mysql和一堆memcached服务器来应付读的问题应用程序首先从memcached中获取数据，获取不到再从数据库中获得并保存在 memcached中，以前看过一篇文章说好的应用95％的数据从memcache的中获得，3％的数据从mysql的query cache中获得，剩下2％才去查表，对比一下你的应用，差距有多远？
* 通过mysql复制（master-slave）来解决读的问题
首先mysql数据库通过master-slave读写分离，多个slave来应对应用程序读的操作。
三、为什么不用mysql的query cache？
我们都知道mysql有个query cache，可以缓存上次查询的结果，可实际上帮不上太多的忙，下面是mysql quety cache的不足：
* 只能有一个实例
意味着你能存储内容的上限就是你服务器的可用内存，一台服务器能有多少内存？你又能存多少呢？
* 只要有写操作，mysql的query cache就失效
只要数据库内容稍有改变，那怕改变的是其他行，mysql的query cache也会失效
* mysql的query cache只能缓存数据库数据行
意味着其他内容都不行，比如数组，比如对象，而memcached理论上可以缓存任何内容，甚至文件^_^
四、Fotolog的缓存技术
* 非确定性缓存你不确定你要的数据缓存中有没有，你也不知道是不是过期了，于是你就试探性的问memcached，我要的什么什么数据你那有吗？我可不要过期的数据啊，memcached告诉你说有并且给你，你就开心了，如果没有呢，你就要从数据库或者别的地方去获取了，这是 memcached典型的应用。主要应用在：
1.复杂的数据需要多次读取，你的数据库做了分片处理，从多个数据库中获取数据并组合起来是一个非常大的开销，你大可以把这些数据取出来之后存到memcached中
2.mysql query cache的一个好的替代方案，这样数据库其他部门改变了，只要自己没改变就没问题（注意数据库更新的问题，后面会提到）
3.把关系或者列表缓存起来，比如某个栏目下的多篇文章列表
4.被多个页面调用并且获取起来很慢的数据，或者是更新很慢的数据，比如文章浏览排行榜
5.如果cache的开销超过重新获取的开销，那么不要缓存它吧
6.标签云和自动建议(类似google sugest)
例如：当一个用户上传一个图片，这个用户的好友页面上都要列出这张图片来，那么把它缓存起来吧。
潜在问题：
memcached消耗的主要是服务器内存，对CPU消耗很小，所以Fotolog把memcached部署在他们的应用服务器上（貌似我们也是这样），他们遇到了CPU搞到90％的使用率（怎么会那么高？哪出问题了吧）、内存回收（这是个大问题）等等问题。
* 状态缓存把应用服务的当前状态存在memcached中主要应用在：
1.“昂贵”的操作，开销大的操作
2.sessions会话，Flickr把session存在数据库中，个人感觉还是存memcached比较“便宜”些，如果memecached服务器down掉了，那么重新登录吧。
3.记录用户在线信息(我们也是这样做的)
* 确定性缓存对于某些特定数据库的全部内容，都缓存到memcached，有一个专门的应用服务来保障你要的数据都在memcached中，其他应用服务直接从memcached中获取数据而不去取数据库，因为数据库已经全部保存到memcached中并保持同步。主要应用在：
1.读取伸展，所有的读取都从memcached中获得，数据库没有负载
2.”永不过期“(相对的)的数据，比如行政规划数据，变动很小吧
3.经常调用的内容
4.用户的认证信息
5.用户的概要信息
6.用户的参数设置
7.用户当前常用的媒体文件列表，比如用户的图片
8.用户登录，不走数据库，只走memcached（个人觉得这个不太好，登录信息还是需要持久化的，用类似BDB这样效果也不错）
使用方式：
1.多个专门的缓存池而不是一个大的缓存服务器，多个缓存池保障了高可用性，一个缓存实例挂掉了走其他的缓存实例，所有的缓存实例挂掉了，走数据库（估计数据库抗不住^_^）
2.所有的缓存池都用程序来维护，比如数据库有更新时，程序自动把更新后的内容同步到多个缓存实例中
3.服务器重启之后，缓存要比网站先启动，这就意味着当网站已经启动了，所有的缓存都可用
4.读取的请求可以负载均衡到多个缓存实例中去，高性能，高可靠性
潜在的问题：
1.你需要足够多的内存来存储那么多的数据
2.数据以行记录数据，而memcached以对象来存储数据，你的逻辑要把行列的数据转换成缓存对象
3.要维护多个缓存实例非常麻烦,Fotolog用Java/Hibernate，他们自己写了个客户端来轮询
4.管理多个缓存实例会增加应用程序的许多开销，但这些开销相对于多个缓存得到的好处来说算不了什么
* 主动缓存数据魔法般的出现在缓存中，当数据库中有更新的时候，缓存立马填充，更新的数据被调用的可能性更高（比如一篇新文章，看的的人当然多），是非确定性缓存的一种变形(原文是It’s non-deterministic caching with a twist.我觉得这样翻译怪怪的)。主要应用在：
1.预填充缓存：让memcached尽可能的少调用mysql如果内容不展现的话。
2.“预热”缓存：当你需要跨数据中心复制的时候
使用步骤：
1.解析数据库更新的二进制日志，发现数据库更新时对memcached也进行同样的更新
2.执行用户自定义函数，设置触发器调用UDF更新，具体参考http://tangent.org/586/Memcached_Functions_for_MySQL.html
3.使用BLACKHOLE策略，传说中Facebook也用mysql的Blackhole存储引擎来填充缓存，写到Blackhole的数据复制到缓存中，Facebook用这来设置数据作废以及跨国界的复制，好处是数据库的复制不走mysql，这就意味着没有二进制日志以及对CPU使用不那么多（啊？难道通过memcached 存储二进制日志，然后复制到不同的数据库？有经验的同志在这个话题上可以补充。）
* 文件系统缓存把文件直接缓存在memcached中，哇，够BT的，减轻NFS的负担，估计只缓存那些过于热门的图片吧。
* 部分页面内容缓存如果页面的某些部分获取起来非常费劲，以其缓存页面的原始数据还不如把页面的部分内容直接缓存起来直接调用
* 应用程序级别的复制通过API来更新缓存，API的执行细节如下：1.一个应用把数据写到某个缓存实例，这个缓存实例把内容复制到其他缓存实例（memcached同步）
2.自动获得缓存池地址以及实例个数
3.同时对多个缓存实例更新
4.如果某个缓存实例down掉了，跳到下一个实例，直到更新成功
整个过程非常高效以及低开销
* 其他技巧1.多节点以应对”单点故障”2.使用热备技术，当某个节点down掉了，另外一台服务自动替换成它的IP，这样客户端不用更新memcached的IP地址
3.memcached可以通过TCP/UDP访问，持续连接可以减轻负载，系统设计成可同时承受1000个连接
4.不同的应用服务，不同的缓存服务器群
5.检查一下你的数据大小是否匹配你分配的缓存，更多请参考http://download.tangent.org/talks/Memcached%20Study.pdf
6.不要考虑数据行缓存，缓存复杂的对象
7.不要在你的数据库服务器上跑memcached，两个都是吃内存的怪兽
8.不要被TCP延迟困扰，本地的TCP/IP对内存复制是做了优化的
9.尽可能的并行处理数据
10.并不是所有的memcached的客户端都是一样的，仔细研究你用的语言所对应的（好像php和memcached配合的不错）
11.尽可能的是数据过期而不是使数据无效，memcached可以设定过期时间
12.选择一个好的缓存标识key，比如更新的时候加上版本号
13.把版本号存储在memcached中
一、关于memcached
还不知道这个？那你去面试的时候要吃亏了，赶紧去官方网站看一下http://www.danga.com/memcached/，另外google一下用法，硬盘总是太慢，把数据存在内存里面吧，如果你只有一台服务器，推荐用一下APC(Facebook在用)或者eaccelerator或者Xcache(国人开发的)，这些产品单机效果更好，如果你需要分布式的缓存方案，那么用memcached吧。
二、memcached如何与mysql并肩作战？
* 通过数据库分片来解决数据库写扩展的问题把数据库分片，部署到不同的服务器上，免得只有一个主服务器，写操作成为瓶颈以及可能有的“单点故障”，一般的数据库分片主要是按照业务来分，尽可能的拆分业务，不相干的都独立起来做成服务也好
* 前端mysql和一堆memcached服务器来应付读的问题应用程序首先从memcached中获取数据，获取不到再从数据库中获得并保存在 memcached中，以前看过一篇文章说好的应用95％的数据从memcache的中获得，3％的数据从mysql的query cache中获得，剩下2％才去查表，对比一下你的应用，差距有多远？
* 通过mysql复制（master-slave）来解决读的问题
首先mysql数据库通过master-slave读写分离，多个slave来应对应用程序读的操作。
三、为什么不用mysql的query cache？
我们都知道mysql有个query cache，可以缓存上次查询的结果，可实际上帮不上太多的忙，下面是mysql quety cache的不足：
* 只能有一个实例
意味着你能存储内容的上限就是你服务器的可用内存，一台服务器能有多少内存？你又能存多少呢？
* 只要有写操作，mysql的query cache就失效
只要数据库内容稍有改变，那怕改变的是其他行，mysql的query cache也会失效
* mysql的query cache只能缓存数据库数据行
意味着其他内容都不行，比如数组，比如对象，而memcached理论上可以缓存任何内容，甚至文件^_^
四、Fotolog的缓存技术
* 非确定性缓存你不确定你要的数据缓存中有没有，你也不知道是不是过期了，于是你就试探性的问memcached，我要的什么什么数据你那有吗？我可不要过期的数据啊，memcached告诉你说有并且给你，你就开心了，如果没有呢，你就要从数据库或者别的地方去获取了，这是 memcached典型的应用。主要应用在：
1.复杂的数据需要多次读取，你的数据库做了分片处理，从多个数据库中获取数据并组合起来是一个非常大的开销，你大可以把这些数据取出来之后存到memcached中
2.mysql query cache的一个好的替代方案，这样数据库其他部门改变了，只要自己没改变就没问题（注意数据库更新的问题，后面会提到）
3.把关系或者列表缓存起来，比如某个栏目下的多篇文章列表
4.被多个页面调用并且获取起来很慢的数据，或者是更新很慢的数据，比如文章浏览排行榜
5.如果cache的开销超过重新获取的开销，那么不要缓存它吧
6.标签云和自动建议(类似google sugest)
例如：当一个用户上传一个图片，这个用户的好友页面上都要列出这张图片来，那么把它缓存起来吧。
潜在问题：
memcached消耗的主要是服务器内存，对CPU消耗很小，所以Fotolog把memcached部署在他们的应用服务器上（貌似我们也是这样），他们遇到了CPU搞到90％的使用率（怎么会那么高？哪出问题了吧）、内存回收（这是个大问题）等等问题。
* 状态缓存把应用服务的当前状态存在memcached中主要应用在：
1.“昂贵”的操作，开销大的操作
2.sessions会话，Flickr把session存在数据库中，个人感觉还是存memcached比较“便宜”些，如果memecached服务器down掉了，那么重新登录吧。
3.记录用户在线信息(我们也是这样做的)
* 确定性缓存对于某些特定数据库的全部内容，都缓存到memcached，有一个专门的应用服务来保障你要的数据都在memcached中，其他应用服务直接从memcached中获取数据而不去取数据库，因为数据库已经全部保存到memcached中并保持同步。主要应用在：
1.读取伸展，所有的读取都从memcached中获得，数据库没有负载
2.”永不过期“(相对的)的数据，比如行政规划数据，变动很小吧
3.经常调用的内容
4.用户的认证信息
5.用户的概要信息
6.用户的参数设置
7.用户当前常用的媒体文件列表，比如用户的图片
8.用户登录，不走数据库，只走memcached（个人觉得这个不太好，登录信息还是需要持久化的，用类似BDB这样效果也不错）
使用方式：
1.多个专门的缓存池而不是一个大的缓存服务器，多个缓存池保障了高可用性，一个缓存实例挂掉了走其他的缓存实例，所有的缓存实例挂掉了，走数据库（估计数据库抗不住^_^）
2.所有的缓存池都用程序来维护，比如数据库有更新时，程序自动把更新后的内容同步到多个缓存实例中
3.服务器重启之后，缓存要比网站先启动，这就意味着当网站已经启动了，所有的缓存都可用
4.读取的请求可以负载均衡到多个缓存实例中去，高性能，高可靠性
潜在的问题：
1.你需要足够多的内存来存储那么多的数据
2.数据以行记录数据，而memcached以对象来存储数据，你的逻辑要把行列的数据转换成缓存对象
3.要维护多个缓存实例非常麻烦,Fotolog用Java/Hibernate，他们自己写了个客户端来轮询
4.管理多个缓存实例会增加应用程序的许多开销，但这些开销相对于多个缓存得到的好处来说算不了什么
* 主动缓存数据魔法般的出现在缓存中，当数据库中有更新的时候，缓存立马填充，更新的数据被调用的可能性更高（比如一篇新文章，看的的人当然多），是非确定性缓存的一种变形(原文是It’s non-deterministic caching with a twist.我觉得这样翻译怪怪的)。主要应用在：
1.预填充缓存：让memcached尽可能的少调用mysql如果内容不展现的话。
2.“预热”缓存：当你需要跨数据中心复制的时候
使用步骤：
1.解析数据库更新的二进制日志，发现数据库更新时对memcached也进行同样的更新
2.执行用户自定义函数，设置触发器调用UDF更新，具体参考http://tangent.org/586/Memcached_Functions_for_MySQL.html
3.使用BLACKHOLE策略，传说中Facebook也用mysql的Blackhole存储引擎来填充缓存，写到Blackhole的数据复制到缓存中，Facebook用这来设置数据作废以及跨国界的复制，好处是数据库的复制不走mysql，这就意味着没有二进制日志以及对CPU使用不那么多（啊？难道通过memcached 存储二进制日志，然后复制到不同的数据库？有经验的同志在这个话题上可以补充。）
* 文件系统缓存把文件直接缓存在memcached中，哇，够BT的，减轻NFS的负担，估计只缓存那些过于热门的图片吧。
* 部分页面内容缓存如果页面的某些部分获取起来非常费劲，以其缓存页面的原始数据还不如把页面的部分内容直接缓存起来直接调用
* 应用程序级别的复制通过API来更新缓存，API的执行细节如下：1.一个应用把数据写到某个缓存实例，这个缓存实例把内容复制到其他缓存实例（memcached同步）
2.自动获得缓存池地址以及实例个数
3.同时对多个缓存实例更新
4.如果某个缓存实例down掉了，跳到下一个实例，直到更新成功
整个过程非常高效以及低开销
* 其他技巧1.多节点以应对”单点故障”2.使用热备技术，当某个节点down掉了，另外一台服务自动替换成它的IP，这样客户端不用更新memcached的IP地址
3.memcached可以通过TCP/UDP访问，持续连接可以减轻负载，系统设计成可同时承受1000个连接
4.不同的应用服务，不同的缓存服务器群
5.检查一下你的数据大小是否匹配你分配的缓存，更多请参考http://download.tangent.org/talks/Memcached%20Study.pdf
6.不要考虑数据行缓存，缓存复杂的对象
7.不要在你的数据库服务器上跑memcached，两个都是吃内存的怪兽
8.不要被TCP延迟困扰，本地的TCP/IP对内存复制是做了优化的
9.尽可能的并行处理数据
10.并不是所有的memcached的客户端都是一样的，仔细研究你用的语言所对应的（好像php和memcached配合的不错）
11.尽可能的是数据过期而不是使数据无效，memcached可以设定过期时间
12.选择一个好的缓存标识key，比如更新的时候加上版本号
13.把版本号存储在memcached中
这两天在做WEB SERVICE,想详细了解一下soap提交的数据,于是把$_SERVER和$_REQUEST两个数组全打在日志里,但就是没有看见POST的内容. 没法只得找了个本地抓包软件抓了下.想了一下肯定是$_REQUEST或$_POST数组都是解析过的数据,对于非a=b方式的数据无法解析,所以是空的!
今天在看XMLRPC的一文章时(http://www.programfan.com/article/2944.html),发现了 $HTTP_RAW_POST_DATA 这个变量能取到post的内容.网上有文章如下介绍
The RAW / uninterpreted HTTP POST information can be accessed with: $GLOBALS['HTTP_RAW_POST_DATA'] This is useful in cases where the post Content-Type is not something PHP understands (such as text/xml).
意思是，由于PHP默认只识别application/x-www.form-urlencoded标准的数据类型，因此，对型如text/xml的内容无法解析为$_POST数组，故保留原型，交给$HTTP_RAW_POST_DAT来接收。
今天在看XMLRPC的一文章时(http://www.programfan.com/article/2944.html),发现了 $HTTP_RAW_POST_DATA 这个变量能取到post的内容.网上有文章如下介绍
The RAW / uninterpreted HTTP POST information can be accessed with: $GLOBALS['HTTP_RAW_POST_DATA'] This is useful in cases where the post Content-Type is not something PHP understands (such as text/xml).
意思是，由于PHP默认只识别application/x-www.form-urlencoded标准的数据类型，因此，对型如text/xml的内容无法解析为$_POST数组，故保留原型，交给$HTTP_RAW_POST_DAT来接收。
telnet到memcached服务器后有很多的命令可以使用，除了大家熟知的add、get、set、incr、decr、replace、delete等赋值命令外，还有一系列的获取服务器信息的命令，这部分命令都是以stats开头的。
用PHP的Memcache::getStats($cmd)也可以访问这些命令
常用的命令
stats
显示服务器信息、统计数据等
stats reset
清空统计数据
stats malloc
显示内存分配数据
stats maps
这个不太确定，看源代码是把/proc/self/maps的数据显示出来。这个文件的数据貌似是动态库的映射地址？
stats maps
00365000-00378000 r-xp 00000000 08:01 149004 /lib/libnsl-2.3.4.so
00378000-00379000 r--p 00012000 08:01 149004 /lib/libnsl-2.3.4.so
00379000-0037a000 rw-p 00013000 08:01 149004 /lib/libnsl-2.3.4.so
0037a000-0037c000 rw-p 0037a000 00:00 0
0070c000-00722000 r-xp 00000000 08:01 147620 /lib/ld-2.3.4.so
00722000-00723000 r--p 00015000 08:01 147620 /lib/ld-2.3.4.so
00723000-00724000 rw-p 00016000 08:01 147620 /lib/ld-2.3.4.so
00726000-0084c000 r-xp 00000000 08:01 147621 /lib/tls/libc-2.3.4.so
0084c000-0084e000 r--p 00125000 08:01 147621 /lib/tls/libc-2.3.4.so
0084e000-00850000 rw-p 00127000 08:01 147621 /lib/tls/libc-2.3.4.so
00850000-00852000 rw-p 00850000 00:00 0
00891000-0089f000 r-xp 00000000 08:01 147624 /lib/tls/libpthread-2.3.4.so
0089f000-008a0000 r--p 0000d000 08:01 147624 /lib/tls/libpthread-2.3.4.so
008a0000-008a1000 rw-p 0000e000 08:01 147624 /lib/tls/libpthread-2.3.4.so
008a1000-008a3000 rw-p 008a1000 00:00 0
008a5000-008b4000 r-xp 00000000 08:01 147628 /lib/libresolv-2.3.4.so
008b4000-008b5000 r--p 0000f000 08:01 147628 /lib/libresolv-2.3.4.so
008b5000-008b6000 rw-p 00010000 08:01 147628 /lib/libresolv-2.3.4.so
008b6000-008b8000 rw-p 008b6000 00:00 0
009c7000-009cf000 r-xp 00000000 08:01 149005 /lib/tls/librt-2.3.4.so
009cf000-009d0000 r--p 00007000 08:01 149005 /lib/tls/librt-2.3.4.so
009d0000-009d1000 rw-p 00008000 08:01 149005 /lib/tls/librt-2.3.4.so
009d1000-009db000 rw-p 009d1000 00:00 0
00d28000-00d3b000 r-xp 00000000 08:02 688822 /usr/local/sinawap/lib/libevent-1.4.so.2.0.0
00d3b000-00d3c000 rw-p 00013000 08:02 688822 /usr/local/sinawap/lib/libevent-1.4.so.2.0.0
00d3c000-00d3d000 rw-p 00d3c000 00:00 0
08048000-08052000 r-xp 00000000 08:02 905179 /usr/local/sinawap/bin/memcached
08052000-08053000 rw-p 0000a000 08:02 905179 /usr/local/sinawap/bin/memcached
08053000-08056000 rw-p 08053000 00:00 0
08499000-084ba000 rw-p 08499000 00:00 0
b7f64000-b7fa8000 rw-p b7f64000 00:00 0
bff9f000-c0000000 rw-p bff9f000 00:00 0
ffffe000-fffff000 r-xp 00000000 00:00 0
stats cachedump slab_id limit_num
显示某个slab中的前limit_num个key列表，显示格式如下
ITEM key_name [ value_length b; expire_time|access_time s]
其中，memcached 1.2.2及以前版本显示的是 访问时间(timestamp)
1.2.4以上版本，包括1.2.4显示 过期时间(timestamp)
如果是永不过期的key，expire_time会显示为服务器启动的时间
stats cachedump 7 2
ITEM copy_test1 [250 b; 1207795754 s]
ITEM copy_test [248 b; 1207793649 s]
stats slabs
显示各个slab的信息，包括chunk的大小、数目、使用情况等
stats items
显示各个slab中item的数目和最老item的年龄(最后一次访问距离现在的秒数)
stats detail [on|off|dump]
设置或者显示详细操作记录
参数为on，打开详细操作记录
参数为off，关闭详细操作记录
参数为dump，显示详细操作记录(每一个键值get、set、hit、del的次数)
stats detail dump
PREFIX copy_test2 get 1 hit 1 set 0 del 0
PREFIX copy_test1 get 1 hit 1 set 0 del 0
PREFIX cpy get 1 hit 0 set 0 del 0
用PHP的Memcache::getStats($cmd)也可以访问这些命令
常用的命令
stats
显示服务器信息、统计数据等
stats reset
清空统计数据
stats malloc
显示内存分配数据
stats maps
这个不太确定，看源代码是把/proc/self/maps的数据显示出来。这个文件的数据貌似是动态库的映射地址？
stats maps
00365000-00378000 r-xp 00000000 08:01 149004 /lib/libnsl-2.3.4.so
00378000-00379000 r--p 00012000 08:01 149004 /lib/libnsl-2.3.4.so
00379000-0037a000 rw-p 00013000 08:01 149004 /lib/libnsl-2.3.4.so
0037a000-0037c000 rw-p 0037a000 00:00 0
0070c000-00722000 r-xp 00000000 08:01 147620 /lib/ld-2.3.4.so
00722000-00723000 r--p 00015000 08:01 147620 /lib/ld-2.3.4.so
00723000-00724000 rw-p 00016000 08:01 147620 /lib/ld-2.3.4.so
00726000-0084c000 r-xp 00000000 08:01 147621 /lib/tls/libc-2.3.4.so
0084c000-0084e000 r--p 00125000 08:01 147621 /lib/tls/libc-2.3.4.so
0084e000-00850000 rw-p 00127000 08:01 147621 /lib/tls/libc-2.3.4.so
00850000-00852000 rw-p 00850000 00:00 0
00891000-0089f000 r-xp 00000000 08:01 147624 /lib/tls/libpthread-2.3.4.so
0089f000-008a0000 r--p 0000d000 08:01 147624 /lib/tls/libpthread-2.3.4.so
008a0000-008a1000 rw-p 0000e000 08:01 147624 /lib/tls/libpthread-2.3.4.so
008a1000-008a3000 rw-p 008a1000 00:00 0
008a5000-008b4000 r-xp 00000000 08:01 147628 /lib/libresolv-2.3.4.so
008b4000-008b5000 r--p 0000f000 08:01 147628 /lib/libresolv-2.3.4.so
008b5000-008b6000 rw-p 00010000 08:01 147628 /lib/libresolv-2.3.4.so
008b6000-008b8000 rw-p 008b6000 00:00 0
009c7000-009cf000 r-xp 00000000 08:01 149005 /lib/tls/librt-2.3.4.so
009cf000-009d0000 r--p 00007000 08:01 149005 /lib/tls/librt-2.3.4.so
009d0000-009d1000 rw-p 00008000 08:01 149005 /lib/tls/librt-2.3.4.so
009d1000-009db000 rw-p 009d1000 00:00 0
00d28000-00d3b000 r-xp 00000000 08:02 688822 /usr/local/sinawap/lib/libevent-1.4.so.2.0.0
00d3b000-00d3c000 rw-p 00013000 08:02 688822 /usr/local/sinawap/lib/libevent-1.4.so.2.0.0
00d3c000-00d3d000 rw-p 00d3c000 00:00 0
08048000-08052000 r-xp 00000000 08:02 905179 /usr/local/sinawap/bin/memcached
08052000-08053000 rw-p 0000a000 08:02 905179 /usr/local/sinawap/bin/memcached
08053000-08056000 rw-p 08053000 00:00 0
08499000-084ba000 rw-p 08499000 00:00 0
b7f64000-b7fa8000 rw-p b7f64000 00:00 0
bff9f000-c0000000 rw-p bff9f000 00:00 0
ffffe000-fffff000 r-xp 00000000 00:00 0
stats cachedump slab_id limit_num
显示某个slab中的前limit_num个key列表，显示格式如下
ITEM key_name [ value_length b; expire_time|access_time s]
其中，memcached 1.2.2及以前版本显示的是 访问时间(timestamp)
1.2.4以上版本，包括1.2.4显示 过期时间(timestamp)
如果是永不过期的key，expire_time会显示为服务器启动的时间
stats cachedump 7 2
ITEM copy_test1 [250 b; 1207795754 s]
ITEM copy_test [248 b; 1207793649 s]
stats slabs
显示各个slab的信息，包括chunk的大小、数目、使用情况等
stats items
显示各个slab中item的数目和最老item的年龄(最后一次访问距离现在的秒数)
stats detail [on|off|dump]
设置或者显示详细操作记录
参数为on，打开详细操作记录
参数为off，关闭详细操作记录
参数为dump，显示详细操作记录(每一个键值get、set、hit、del的次数)
stats detail dump
PREFIX copy_test2 get 1 hit 1 set 0 del 0
PREFIX copy_test1 get 1 hit 1 set 0 del 0
PREFIX cpy get 1 hit 0 set 0 del 0
memcached的服务器客户端通信并不使用复杂的XML等格式，而使用简单的基于文本行的协议。因此，通过telnet 也能在memcached上保存数据、取得数据。下面是例子。
$ telnet localhost 11211
Trying 127.0.0.1...
Connected to localhost.localdomain (127.0.0.1).
Escape character is '^]'.
set foo 0 0 3 （保存命令）
bar （数据）
STORED （结果）
get foo （取得命令）
VALUE foo 0 3 （数据）
bar （数据）
delete foo
DELETED
Tencent:~ # telnet 172.24.18.5* 11211
Trying 172.24.18.56...
Connected to 172.24.18.56.
Escape character is '^]'.
set foo 0 0 3
bar
STORED
get foo
VALUE foo 0 3
bar
END
delete foo
DELETED
清空全部Memcached的变量，shell下的Telnet操作如下：
[/usr/local/apache2/*/vhost.d]# telnet 172.25.*.70 12000
Trying 172.25.38.70...
Connected to 172.25.38.70.
Escape character is '^]'.
flush_all
OK
另辟蹊径-检查memcached中指定的key是否存在：
们都知道，memcached的协议中是没有任何一个协议提供给我们检查某个key是否存在的。但是我们可能会有这样的需求。
一些开源的客户端提供了KeyExists（）这样的方法，但是其实现原理是调用了memcached的get协议，以此来达到判断某个key是否存在的目的：能取到表示这个key存在，取不到则不存在。这样的效率是比较低的，特别是当数据包比较大的情况下。
在不读取memcached的数据的情况下，如何高效的判断某个key是否存在呢？
大家都知道memcached的cas（check and set）协议吧，该协议在写memcached时先判断是否有人在你之前更新过数据，如果有更新过，则此次写memcached失败。
那我们来看一下cas的语法：
cas key flag exptime bytes version\r\n
其中的version是memcached内部维护的一个版本号，是个uint64_t的值，这个值是调用memcached的gets协议获得的，version从1开始，memcached刚启动的时候，节点数为0，从存储第一个节点开始，version不断累加。因此，version是不可能出现0这个情况，这点很重要，是达到我们的目的的一个关键点。
好了，我们已经知道了cas的用法，根据它的特性可以实现我们检查一个key是否存在的目的，聪明的读者可能已经知道该怎么做了吧。
比如要检查foo这个key是否存在，可以构造这样的命令
cas foo 0 0 1 0\r\n
这里构造一个字节的数据包，将version字段设置成0，尝试写memcached。
如果foo已经存在，因为它的version不可能等于0，所以memcached提示EXISTS
如果foo不存在，memcached提示NOT_FOUND
------------------------------------------
set foo 0 0 3 # 先写入
bar
STORED
cas foo 0 0 1 0 # 判断foo是否存在，系统提示EXISTS
a
EXISTS
delete foo # 将foo删除
DELETED
cas foo 0 0 1 0 # 判断foo是否存在，系统提示NOT_FOUND
a
NOT_FOUND
------------------------------------------
这样，我们就知道foo这个key是否存在了。
----------------------------------------------引用-------------------------------------------------
memcached的基本设置：
-p 监听的端口
-l 连接的IP地址, 默认是本机
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-u 以的身份运行 (仅在以root运行的时候有效)
-m 最大内存使用，单位MB。默认64MB
-M 内存耗尽时返回错误，而不是删除项
-c 最大同时连接数，默认是1024
-f 块大小增长因子，默认是1.25
-n 最小分配空间，key+value+flags默认是48
-h 显示帮助
mixi的设置,单台:
每台memcached服务器仅启动一个memcached进程。分配给memcached的内存为3GB，启动参数如下：
/usr/bin/memcached -p 11211 -u nobody -m 3000 -c 30720
由于使用了x86_64的操作系统，因此能分配2GB以上的内存。32位操作系统中，每个进程最多只能使用2GB内存。也曾经考虑过启动多个分配2GB以下内存的进程，但这样一台服务器上的TCP连接数就会成倍增加，管理上也变得复杂，所以mixi就统一使用了64位操作系统。
另外，虽然服务器的内存为4GB，却仅分配了3GB，是因为内存分配量超过这个值，就有可能导致内存交换(swap)。连载的第2次中前坂讲解过了memcached的内存存储“slab allocator”，当时说过，memcached启动时指定的内存分配量是memcached用于保存数据的量，没有包括“slab allocator”本身占用的内存、以及为了保存数据而设置的管理空间。因此，memcached进程的实际内存分配量要比指定的容量要大，这一点应当注意。
mixi保存在memcached中的数据大部分都比较小。这样，进程的大小要比指定的容量大很多。因此，我们反复改变内存分配量进行验证，确认了3GB的大小不会引发swap，这就是现在应用的数值。
$ telnet localhost 11211
Trying 127.0.0.1...
Connected to localhost.localdomain (127.0.0.1).
Escape character is '^]'.
set foo 0 0 3 （保存命令）
bar （数据）
STORED （结果）
get foo （取得命令）
VALUE foo 0 3 （数据）
bar （数据）
delete foo
DELETED
Tencent:~ # telnet 172.24.18.5* 11211
Trying 172.24.18.56...
Connected to 172.24.18.56.
Escape character is '^]'.
set foo 0 0 3
bar
STORED
get foo
VALUE foo 0 3
bar
END
delete foo
DELETED
清空全部Memcached的变量，shell下的Telnet操作如下：
[/usr/local/apache2/*/vhost.d]# telnet 172.25.*.70 12000
Trying 172.25.38.70...
Connected to 172.25.38.70.
Escape character is '^]'.
flush_all
OK
另辟蹊径-检查memcached中指定的key是否存在：
们都知道，memcached的协议中是没有任何一个协议提供给我们检查某个key是否存在的。但是我们可能会有这样的需求。
一些开源的客户端提供了KeyExists（）这样的方法，但是其实现原理是调用了memcached的get协议，以此来达到判断某个key是否存在的目的：能取到表示这个key存在，取不到则不存在。这样的效率是比较低的，特别是当数据包比较大的情况下。
在不读取memcached的数据的情况下，如何高效的判断某个key是否存在呢？
大家都知道memcached的cas（check and set）协议吧，该协议在写memcached时先判断是否有人在你之前更新过数据，如果有更新过，则此次写memcached失败。
那我们来看一下cas的语法：
cas key flag exptime bytes version\r\n
其中的version是memcached内部维护的一个版本号，是个uint64_t的值，这个值是调用memcached的gets协议获得的，version从1开始，memcached刚启动的时候，节点数为0，从存储第一个节点开始，version不断累加。因此，version是不可能出现0这个情况，这点很重要，是达到我们的目的的一个关键点。
好了，我们已经知道了cas的用法，根据它的特性可以实现我们检查一个key是否存在的目的，聪明的读者可能已经知道该怎么做了吧。
比如要检查foo这个key是否存在，可以构造这样的命令
cas foo 0 0 1 0\r\n
这里构造一个字节的数据包，将version字段设置成0，尝试写memcached。
如果foo已经存在，因为它的version不可能等于0，所以memcached提示EXISTS
如果foo不存在，memcached提示NOT_FOUND
------------------------------------------
set foo 0 0 3 # 先写入
bar
STORED
cas foo 0 0 1 0 # 判断foo是否存在，系统提示EXISTS
a
EXISTS
delete foo # 将foo删除
DELETED
cas foo 0 0 1 0 # 判断foo是否存在，系统提示NOT_FOUND
a
NOT_FOUND
------------------------------------------
这样，我们就知道foo这个key是否存在了。
----------------------------------------------引用-------------------------------------------------
memcached的基本设置：
-p 监听的端口
-l 连接的IP地址, 默认是本机
-d start 启动memcached服务
-d restart 重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-u 以的身份运行 (仅在以root运行的时候有效)
-m 最大内存使用，单位MB。默认64MB
-M 内存耗尽时返回错误，而不是删除项
-c 最大同时连接数，默认是1024
-f 块大小增长因子，默认是1.25
-n 最小分配空间，key+value+flags默认是48
-h 显示帮助
mixi的设置,单台:
每台memcached服务器仅启动一个memcached进程。分配给memcached的内存为3GB，启动参数如下：
/usr/bin/memcached -p 11211 -u nobody -m 3000 -c 30720
由于使用了x86_64的操作系统，因此能分配2GB以上的内存。32位操作系统中，每个进程最多只能使用2GB内存。也曾经考虑过启动多个分配2GB以下内存的进程，但这样一台服务器上的TCP连接数就会成倍增加，管理上也变得复杂，所以mixi就统一使用了64位操作系统。
另外，虽然服务器的内存为4GB，却仅分配了3GB，是因为内存分配量超过这个值，就有可能导致内存交换(swap)。连载的第2次中前坂讲解过了memcached的内存存储“slab allocator”，当时说过，memcached启动时指定的内存分配量是memcached用于保存数据的量，没有包括“slab allocator”本身占用的内存、以及为了保存数据而设置的管理空间。因此，memcached进程的实际内存分配量要比指定的容量要大，这一点应当注意。
mixi保存在memcached中的数据大部分都比较小。这样，进程的大小要比指定的容量大很多。因此，我们反复改变内存分配量进行验证，确认了3GB的大小不会引发swap，这就是现在应用的数值。
Redhat5下利用yum安装SVN客户端
由于Redhat5自带的SVN的版本是1.4.1的，比较老，不能读取SVN1.5的库,所有要更新:
直接运行：yum update subversion
会抱错:
http://ftp.sjtu.edu.cn/centos/5/updates/i386/repodata/repomd.xml: [Errno 14] HTTP Error 403: Forbidden
将repo地址改称USTC（科大的),
即:/etc/yum.repos.d/rhel-debuginfo.repo中的所有ftp.sjtu.edu.cn改成centos.ustc.edu.cn
然后运行yum update subversion就可以了. ......
由于Redhat5自带的SVN的版本是1.4.1的，比较老，不能读取SVN1.5的库,所有要更新:
直接运行：yum update subversion
会抱错:
http://ftp.sjtu.edu.cn/centos/5/updates/i386/repodata/repomd.xml: [Errno 14] HTTP Error 403: Forbidden
将repo地址改称USTC（科大的),
即:/etc/yum.repos.d/rhel-debuginfo.repo中的所有ftp.sjtu.edu.cn改成centos.ustc.edu.cn
然后运行yum update subversion就可以了. ......
http://bbs.5y6s.com/htm_data/20/0702/9283.html
一、什么是C/S和B/S
第一、什么是C/S结构
C/S （Client/Server）结构，即大家熟知的客户机和服务器结构。它是软件系统体系结构，通过它可以充分利用两端硬件环境的优势，将任务合理分配到Client端和Server端来实现，降低了系统的通讯开销。目前大多数应用软件系统都是Client/Server形式的两层结构，由于现在的软件应用系统正在向分布式的Web应用发展，Web和Client/Server 应用都可以进行同样的业务处理，应用不同的模块共享逻辑组件；因此，内部的和外部的用户都可以访问新的和现有的应用系统，通过现有应用系统中的逻辑可以扩展出新的应用系统。这也就是目前应用系统的发展方向。
传统的C／S体系结构虽然采用的是开放模式，但这只是系统开发一级的开放性，在特定的应用中无论是Client端还是Server端都还需要特定的软件支持。由于没能提供用户真正期望的开放环境，C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件， 加之产品的更新换代十分快，已经很难适应百台电脑以上局域网用户同时使用。而且代价高， 效率低。如我院使用的上海超兰公司“案件统计”管理软件就是典型的C／S体系结构管理软件。
第二、什么是B/S结构
B/S（Browser/Server）结构即浏览器和服务器结构。它是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种结构下，用户工作界面是通过WWW浏览器来实现，极少部分事务逻辑在前端（Browser）实现，但是主要事务逻辑在服务器端（Server）实现，形成所谓三层3-tier结构。这样就大大简化了客户端电脑载荷，减轻了系统维护与升级的成本和工作量，降低了用户的总体成本（TCO）。以目前的技术看，局域网建立B/S结构的网络应用，并通过Internet/Intranet模式下数据库应用，相对易于把握、成本也是较低的。它是一次性到位的开发，能实现不同的人员，从不同的地点，以不同的接入方式（比如LAN, WAN, Internet/Intranet等）访问和操作共同的数据库；它能有效地保护数据平台和管理访问权限，服务器数据库也很安全 。特别是在JAVA这样的跨平台语言出现之后，B/S架构管理软件更是方便、快捷、高效。
第三、管理软件主流技术
管理软件技术的主流技术与管理思想一样，也经历了三个发展时期。首先，界面技术从上世纪DOS字符界面到Windows图形界面（或图形用户界面GUI），直至Browser浏览器界面三个不同的发展时期。其次，今天所有电脑的浏览器界面，不仅直观和易于使用，更主要的是基于浏览器平台的任何应用软件其风格都是一样的，使用人对操作培训的要求不高，而且软件可操作性强，易于识别；再者，平台体系结构也从过去单用户发展到今天的文件／服务器（F／S）体系、客户机／服务器（C／S）体系和浏览器／服务器（B／S）体系。
二、C/S和B/S 之比较
C/S和B/S是当今世界开发模式技术架构的两大主流技术。C/S是美国 Borland公司最早研发，B/S是美国微软公司研发。目前，这两项技术以被世界各国所掌握，国内公司以C/S和B/S技术开发出产品也很多。这两种技术都有自己一定的市场份额和客户群，各家企业都说自己的管理软件架构技术功能强大、先进、方便，都能举出各自的客户群体，都有一大群文人墨客为自己摇旗呐喊，广告满天飞，可谓仁者见仁，智者见智。
1、C/S架构软件的优势与劣势
（1）、应用服务器运行数据负荷较轻。最简单的C/S体系结构的数据库应用由两部分组成，即客户应用程序和数据库服务器程序。二者可分别称为前台程序与后台程序。运行数据库服务器程序的机器，也称为应用服务器。一旦服务器程序被启动，就随时等待响应客户程序发来的请求；客户应用程序运行在用户自己的电脑上，对应于数据库服务器，可称为客户电脑，当需要对数据库中的数据进行任何操作时，客户程序就自动地寻找服务器程序，并向其发出请求，服务器程序根据预定的规则作出应答，送回结果，应用服务器运行数据负荷较轻。
（2）、数据的储存管理功能较为透明。在数据库应用中，数据的储存管理功能，是由服务器程序和客户应用程序分别独立进行的，前台应用可以违反的规则，并且通常把那些不同的（不管是已知还是未知的）运行数据，在服务器程序中不集中实现，例如访问者的权限，编号可以重复、必须有客户才能建立定单这样的规则。所有这些，对于工作在前台程序上的最终用户，是“透明”的，他们无须过问（通常也无法干涉）背后的过程，就可以完成自己的一切工作。在客户服务器架构的应用中，前台程序不是非常“瘦小”，麻烦的事情都交给了服务器和网络。在C/S体系的下，数据库不能真正成为公共、专业化的仓库，它受到独立的专门管理。
（3）、C/S架构的劣势是高昂的维护成本且投资大。首先，采用C/S架构，要选择适当的数据库平台来实现数据库数据的真正“统一”，使分布于两地的数据同步完全交由数据库系统去管理，但逻辑上两地的操作者要直接访问同一个数据库才能有效实现，有这样一些问题，如果需要建立“实时”的数据同步，就必须在两地间建立实时的通讯连接，保持两地的数据库服务器在线运行，网络管理工作人员既要对服务器维护管理，又要对客户端维护和管理，这需要高昂的投资和复杂的技术支持，维护成本很高，维护任务量大。
其次，传统的C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件，由于产品的更新换代十分快，代价高和低效率已经不适应工作需要。在JAVA这样的跨平台语言出现之后，B/S架构更是猛烈冲击C/S，并对其形成威胁和挑战。
2、B/S架构软件的优势与劣势
（1）、维护和升级方式简单。目前，软件系统的改进和升级越来越频繁，B/S架构的产品明显体现着更为方便的特性。对一个稍微大一点单位来说，系统管理人员如果需要在几百甚至上千部电脑之间来回奔跑，效率和工作量是可想而知的，但B/S架构的软件只需要管理服务器就行了，所有的客户端只是浏览器，根本不需要做任何的维护。无论用户的规模有多大，有多少分支机构都不会增加任何维护升级的工作量，所有的操作只需要针对服务器进行；如果是异地，只需要把服务器连接专网即可，实现远程维护、升级和共享。所以客户机越来越“瘦”，而服务器越来越“胖”是将来信息化发展的主流方向。今后，软件升级和维护会越来越容易，而使用起来会越来越简单，这对用户人力、物力、时间、费用的节省是显而易见的，惊人的。因此，维护和升级革命的方式是“瘦”客户机，“胖”服务器。
（2）、成本降低，选择更多。大家都知道windows在桌面电脑上几乎一统天下，浏览器成为了标准配置，但在服务器操作系统上windows并不是处于绝对的统治地位。 现在的趋势是凡使用B/S架构的应用管理软件，只需安装在Linux服务器上即可，而且安全性高。所以服务器操作系统的选择是很多的，不管选用那种操作系统都可以让大部分人使用windows作为桌面操作系统电脑不受影响，这就使的最流行免费的Linux操作系统快速发展起来，Linux除了操作系统是免费的以外，连数据库也是免费的，这种选择非常盛行。
比如说很多人每天上“新浪”网，只要安装了浏览器就可以了，并不需要了解“新浪”的服务器用的是什么操作系统，而事实上大部分网站确实没有使用windows操作系统，但用户的电脑本身安装的大部分是windows操作系统。
（3）、应用服务器运行数据负荷较重。由于B/S架构管理软件只安装在服务器端（Server）上，网络管理人员只需要管理服务器就行了，用户界面主要事务逻辑在服务器（Server）端完全通过WWW浏览器实现，极少部分事务逻辑在前端（Browser）实现，所有的客户端只有浏览器，网络管理人员只需要做硬件维护。但是，应用服务器运行数据负荷较重，一旦发生服务器“崩溃”等问题，后果不堪设想。因此，许多单位都备有数据库存储服务器，以防万一。
Web服务作为炙手可热的技术，如何应用到企业的IT系统和商业流程之中、并给企业带来直接的经济效益，一直备受国内外企业管理者的高度关注和推崇。而在近两年，出现了一种技术架构被誉为下一代Web服务的基础架构，它就是SOA（Service-oriented architecture，面向服务架构）。1996年，Gartner最早提出SOA。2002年12月，Gartner提出SOA是”现代应用开发领域最重要的课题”，还预计到2008年，SOA将成为占有绝对优势的软件工程实践方法，主流企业现在就应该在理解和应用SOA开发技能方面进行投资。
更好支持商业流程
SOA并不是一个新事物，IT组织已经成功建立并实施SOA应用软件很多年了，BEA、IBM、等厂商看到了它的价值，纷纷跟进。SOA的目标在于让IT变得更有弹性，以更快地响应业务单位的需求，实现实时企业（Real-Time Enterprise，这是Gartner为SOA描述的愿景目标）。而BEA的CIO Rhonda早在2001年6月就提出要将BEA的IT基础架构转变为SOA，并且从对整个企业架构的控制能力、提升开发效率、加快开发速度、降低在客户化和人员技能的投入等方面取得了不错的成绩。
SOA是在计算环境下设计、开发、应用、管理分散的逻辑（服务）单元的一种规范。这个定义决定了SOA的广泛性。SOA要求开发者从服务集成的角度来设计应用软件，即使这么做的利益不会马上显现。SOA要求开发者超越应用软件来思考，并考虑复用现有的服务，或者检查如何让服务被重复利用。SOA鼓励使用可替代的技术和方法（例如消息机制），通过把服务联系在一起而非编写新代码来构架应用。经过适当构架后，这种消息机制的应用允许公司仅通过调整原有服务模式而非被迫进行大规模新的应用代码的开发，使得在商业环境许可的时间内对变化的市场条件做出快速的响应。
SOA也不仅仅是一种开发的方法论–它还包含管理。例如，应用SOA后，管理者可以方便的管理这些搭建在服务平台上的企业应用，而不是管理单一的应用模块。其原理是，通过分析服务之间的相互调用，SOA使得公司管理人员方便的拿到什么时候、什么原因、哪些商业逻辑被执行的数据信息，这样就帮助了企业管理人员或应用架构师迭代地优化他们的企业业务流程、应用系统。
SOA的一个中心思想就是使得企业应
第一、什么是C/S结构
C/S （Client/Server）结构，即大家熟知的客户机和服务器结构。它是软件系统体系结构，通过它可以充分利用两端硬件环境的优势，将任务合理分配到Client端和Server端来实现，降低了系统的通讯开销。目前大多数应用软件系统都是Client/Server形式的两层结构，由于现在的软件应用系统正在向分布式的Web应用发展，Web和Client/Server 应用都可以进行同样的业务处理，应用不同的模块共享逻辑组件；因此，内部的和外部的用户都可以访问新的和现有的应用系统，通过现有应用系统中的逻辑可以扩展出新的应用系统。这也就是目前应用系统的发展方向。
传统的C／S体系结构虽然采用的是开放模式，但这只是系统开发一级的开放性，在特定的应用中无论是Client端还是Server端都还需要特定的软件支持。由于没能提供用户真正期望的开放环境，C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件， 加之产品的更新换代十分快，已经很难适应百台电脑以上局域网用户同时使用。而且代价高， 效率低。如我院使用的上海超兰公司“案件统计”管理软件就是典型的C／S体系结构管理软件。
第二、什么是B/S结构
B/S（Browser/Server）结构即浏览器和服务器结构。它是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种结构下，用户工作界面是通过WWW浏览器来实现，极少部分事务逻辑在前端（Browser）实现，但是主要事务逻辑在服务器端（Server）实现，形成所谓三层3-tier结构。这样就大大简化了客户端电脑载荷，减轻了系统维护与升级的成本和工作量，降低了用户的总体成本（TCO）。以目前的技术看，局域网建立B/S结构的网络应用，并通过Internet/Intranet模式下数据库应用，相对易于把握、成本也是较低的。它是一次性到位的开发，能实现不同的人员，从不同的地点，以不同的接入方式（比如LAN, WAN, Internet/Intranet等）访问和操作共同的数据库；它能有效地保护数据平台和管理访问权限，服务器数据库也很安全 。特别是在JAVA这样的跨平台语言出现之后，B/S架构管理软件更是方便、快捷、高效。
第三、管理软件主流技术
管理软件技术的主流技术与管理思想一样，也经历了三个发展时期。首先，界面技术从上世纪DOS字符界面到Windows图形界面（或图形用户界面GUI），直至Browser浏览器界面三个不同的发展时期。其次，今天所有电脑的浏览器界面，不仅直观和易于使用，更主要的是基于浏览器平台的任何应用软件其风格都是一样的，使用人对操作培训的要求不高，而且软件可操作性强，易于识别；再者，平台体系结构也从过去单用户发展到今天的文件／服务器（F／S）体系、客户机／服务器（C／S）体系和浏览器／服务器（B／S）体系。
二、C/S和B/S 之比较
C/S和B/S是当今世界开发模式技术架构的两大主流技术。C/S是美国 Borland公司最早研发，B/S是美国微软公司研发。目前，这两项技术以被世界各国所掌握，国内公司以C/S和B/S技术开发出产品也很多。这两种技术都有自己一定的市场份额和客户群，各家企业都说自己的管理软件架构技术功能强大、先进、方便，都能举出各自的客户群体，都有一大群文人墨客为自己摇旗呐喊，广告满天飞，可谓仁者见仁，智者见智。
1、C/S架构软件的优势与劣势
（1）、应用服务器运行数据负荷较轻。最简单的C/S体系结构的数据库应用由两部分组成，即客户应用程序和数据库服务器程序。二者可分别称为前台程序与后台程序。运行数据库服务器程序的机器，也称为应用服务器。一旦服务器程序被启动，就随时等待响应客户程序发来的请求；客户应用程序运行在用户自己的电脑上，对应于数据库服务器，可称为客户电脑，当需要对数据库中的数据进行任何操作时，客户程序就自动地寻找服务器程序，并向其发出请求，服务器程序根据预定的规则作出应答，送回结果，应用服务器运行数据负荷较轻。
（2）、数据的储存管理功能较为透明。在数据库应用中，数据的储存管理功能，是由服务器程序和客户应用程序分别独立进行的，前台应用可以违反的规则，并且通常把那些不同的（不管是已知还是未知的）运行数据，在服务器程序中不集中实现，例如访问者的权限，编号可以重复、必须有客户才能建立定单这样的规则。所有这些，对于工作在前台程序上的最终用户，是“透明”的，他们无须过问（通常也无法干涉）背后的过程，就可以完成自己的一切工作。在客户服务器架构的应用中，前台程序不是非常“瘦小”，麻烦的事情都交给了服务器和网络。在C/S体系的下，数据库不能真正成为公共、专业化的仓库，它受到独立的专门管理。
（3）、C/S架构的劣势是高昂的维护成本且投资大。首先，采用C/S架构，要选择适当的数据库平台来实现数据库数据的真正“统一”，使分布于两地的数据同步完全交由数据库系统去管理，但逻辑上两地的操作者要直接访问同一个数据库才能有效实现，有这样一些问题，如果需要建立“实时”的数据同步，就必须在两地间建立实时的通讯连接，保持两地的数据库服务器在线运行，网络管理工作人员既要对服务器维护管理，又要对客户端维护和管理，这需要高昂的投资和复杂的技术支持，维护成本很高，维护任务量大。
其次，传统的C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件，由于产品的更新换代十分快，代价高和低效率已经不适应工作需要。在JAVA这样的跨平台语言出现之后，B/S架构更是猛烈冲击C/S，并对其形成威胁和挑战。
2、B/S架构软件的优势与劣势
（1）、维护和升级方式简单。目前，软件系统的改进和升级越来越频繁，B/S架构的产品明显体现着更为方便的特性。对一个稍微大一点单位来说，系统管理人员如果需要在几百甚至上千部电脑之间来回奔跑，效率和工作量是可想而知的，但B/S架构的软件只需要管理服务器就行了，所有的客户端只是浏览器，根本不需要做任何的维护。无论用户的规模有多大，有多少分支机构都不会增加任何维护升级的工作量，所有的操作只需要针对服务器进行；如果是异地，只需要把服务器连接专网即可，实现远程维护、升级和共享。所以客户机越来越“瘦”，而服务器越来越“胖”是将来信息化发展的主流方向。今后，软件升级和维护会越来越容易，而使用起来会越来越简单，这对用户人力、物力、时间、费用的节省是显而易见的，惊人的。因此，维护和升级革命的方式是“瘦”客户机，“胖”服务器。
（2）、成本降低，选择更多。大家都知道windows在桌面电脑上几乎一统天下，浏览器成为了标准配置，但在服务器操作系统上windows并不是处于绝对的统治地位。 现在的趋势是凡使用B/S架构的应用管理软件，只需安装在Linux服务器上即可，而且安全性高。所以服务器操作系统的选择是很多的，不管选用那种操作系统都可以让大部分人使用windows作为桌面操作系统电脑不受影响，这就使的最流行免费的Linux操作系统快速发展起来，Linux除了操作系统是免费的以外，连数据库也是免费的，这种选择非常盛行。
比如说很多人每天上“新浪”网，只要安装了浏览器就可以了，并不需要了解“新浪”的服务器用的是什么操作系统，而事实上大部分网站确实没有使用windows操作系统，但用户的电脑本身安装的大部分是windows操作系统。
（3）、应用服务器运行数据负荷较重。由于B/S架构管理软件只安装在服务器端（Server）上，网络管理人员只需要管理服务器就行了，用户界面主要事务逻辑在服务器（Server）端完全通过WWW浏览器实现，极少部分事务逻辑在前端（Browser）实现，所有的客户端只有浏览器，网络管理人员只需要做硬件维护。但是，应用服务器运行数据负荷较重，一旦发生服务器“崩溃”等问题，后果不堪设想。因此，许多单位都备有数据库存储服务器，以防万一。
Web服务作为炙手可热的技术，如何应用到企业的IT系统和商业流程之中、并给企业带来直接的经济效益，一直备受国内外企业管理者的高度关注和推崇。而在近两年，出现了一种技术架构被誉为下一代Web服务的基础架构，它就是SOA（Service-oriented architecture，面向服务架构）。1996年，Gartner最早提出SOA。2002年12月，Gartner提出SOA是”现代应用开发领域最重要的课题”，还预计到2008年，SOA将成为占有绝对优势的软件工程实践方法，主流企业现在就应该在理解和应用SOA开发技能方面进行投资。
更好支持商业流程
SOA并不是一个新事物，IT组织已经成功建立并实施SOA应用软件很多年了，BEA、IBM、等厂商看到了它的价值，纷纷跟进。SOA的目标在于让IT变得更有弹性，以更快地响应业务单位的需求，实现实时企业（Real-Time Enterprise，这是Gartner为SOA描述的愿景目标）。而BEA的CIO Rhonda早在2001年6月就提出要将BEA的IT基础架构转变为SOA，并且从对整个企业架构的控制能力、提升开发效率、加快开发速度、降低在客户化和人员技能的投入等方面取得了不错的成绩。
SOA是在计算环境下设计、开发、应用、管理分散的逻辑（服务）单元的一种规范。这个定义决定了SOA的广泛性。SOA要求开发者从服务集成的角度来设计应用软件，即使这么做的利益不会马上显现。SOA要求开发者超越应用软件来思考，并考虑复用现有的服务，或者检查如何让服务被重复利用。SOA鼓励使用可替代的技术和方法（例如消息机制），通过把服务联系在一起而非编写新代码来构架应用。经过适当构架后，这种消息机制的应用允许公司仅通过调整原有服务模式而非被迫进行大规模新的应用代码的开发，使得在商业环境许可的时间内对变化的市场条件做出快速的响应。
SOA也不仅仅是一种开发的方法论–它还包含管理。例如，应用SOA后，管理者可以方便的管理这些搭建在服务平台上的企业应用，而不是管理单一的应用模块。其原理是，通过分析服务之间的相互调用，SOA使得公司管理人员方便的拿到什么时候、什么原因、哪些商业逻辑被执行的数据信息，这样就帮助了企业管理人员或应用架构师迭代地优化他们的企业业务流程、应用系统。
SOA的一个中心思想就是使得企业应
Crontab计算器：https://tooltt.com/crontab-parse/
1月7日凌晨0点执行一个脚本！
注意：
1.尽量写绝对路径；
2.sh要写/bin/sh
3.给要执行的sh文件，这儿install.sh赋予权限:chmod a+x install.sh
周一到周五每天下午 5:00 寄一封信给 alex@domain.name :
0 17 * * 1-5 mail -s "hi" alex@domain.name < /tmp/maildata
#周一到周五每天下午 5:00 寄一封信给 alex@domain.name :
0 17 * * 1-5 mail -s "hi" alex@domain.name < /tmp/maildata
#每月每天的午夜 0 点 20 分, 2 点 20 分, 4 点 20 分....执行 echo "haha"
20 0-23/2 * * * echo "haha"
#晚上11点到早上8点之间每两个小时，早上8点
0 23-7/2，8 * * * date
#每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点
0 11 4 * mon-wed date
#1月份日早上4点
0 4 1 jan * date
第1列表示分钟1～59 每分钟用*或者 */1表示
第2列表示小时1～23（0表示0点）
第3列表示日期1～31
第4列表示月份1～12
第5列标识号星期0～6（0表示星期天）
第6列要运行的命令
crontab文件的一些例子：
30 21 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每晚的21:30重启apache。
45 4 1,10,22 * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每月1、10、22日的4 : 45重启apache。
10 1 * * 6,0 /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每周六、周日的1 : 10重启apache。
0,30 18-23 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示在每天18 : 00至23 : 00之间每隔30分钟重启apache。
0 23 * * 6 /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每星期六的11 : 00 pm重启apache。
* */1 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子每一小时重启apache
* 23-7/1 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子晚上11点到早上7点之间，每隔一小时重启apache
0 11 4 * mon-wed /usr/local/etc/rc.d/lighttpd restart
#上面的例子每月的4号与每周一到周三的11点重启apache
0 4 1 jan * /usr/local/etc/rc.d/lighttpd restart
#上面的例子一月一号的4点重启apache
来自：http://bbs.chinaunix.net/thread-1699269-1-1.html
0 0 07 01 * /bin/sh /usr/local/tads/htdocs/*/crontab/install.sh >/dev/null 2>&1
1月7日凌晨0点执行一个脚本！
注意：
1.尽量写绝对路径；
2.sh要写/bin/sh
3.给要执行的sh文件，这儿install.sh赋予权限:chmod a+x install.sh
Tencent:/usr/local/tads/htdocs/maestro/crontab # cat /usr/local/tads/htdocs/*/crontab/install.sh
cp -Rf /usr/local/tads/htdocs/*/view/usershow2.php /usr/local/tads/htdocs/*/view/usershow.php
cp -Rf /usr/local/tads/htdocs/*/view/images/flow.jpg.need.replace /usr/local/tads/htdocs/*/view/images/flow.jpg
cp -Rf /usr/local/tads/htdocs/*/view/usershow2.php /usr/local/tads/htdocs/*/view/usershow.php
cp -Rf /usr/local/tads/htdocs/*/view/images/flow.jpg.need.replace /usr/local/tads/htdocs/*/view/images/flow.jpg
周一到周五每天下午 5:00 寄一封信给 alex@domain.name :
0 17 * * 1-5 mail -s "hi" alex@domain.name < /tmp/maildata
#周一到周五每天下午 5:00 寄一封信给 alex@domain.name :
0 17 * * 1-5 mail -s "hi" alex@domain.name < /tmp/maildata
#每月每天的午夜 0 点 20 分, 2 点 20 分, 4 点 20 分....执行 echo "haha"
20 0-23/2 * * * echo "haha"
#晚上11点到早上8点之间每两个小时，早上8点
0 23-7/2，8 * * * date
#每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点
0 11 4 * mon-wed date
#1月份日早上4点
0 4 1 jan * date
第1列表示分钟1～59 每分钟用*或者 */1表示
第2列表示小时1～23（0表示0点）
第3列表示日期1～31
第4列表示月份1～12
第5列标识号星期0～6（0表示星期天）
第6列要运行的命令
crontab文件的一些例子：
30 21 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每晚的21:30重启apache。
45 4 1,10,22 * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每月1、10、22日的4 : 45重启apache。
10 1 * * 6,0 /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每周六、周日的1 : 10重启apache。
0,30 18-23 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示在每天18 : 00至23 : 00之间每隔30分钟重启apache。
0 23 * * 6 /usr/local/etc/rc.d/lighttpd restart
#上面的例子表示每星期六的11 : 00 pm重启apache。
* */1 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子每一小时重启apache
* 23-7/1 * * * /usr/local/etc/rc.d/lighttpd restart
#上面的例子晚上11点到早上7点之间，每隔一小时重启apache
0 11 4 * mon-wed /usr/local/etc/rc.d/lighttpd restart
#上面的例子每月的4号与每周一到周三的11点重启apache
0 4 1 jan * /usr/local/etc/rc.d/lighttpd restart
#上面的例子一月一号的4点重启apache
来自：http://bbs.chinaunix.net/thread-1699269-1-1.html
Memcache是什么？
Memcache是一个自由和开放源代码、高性能、分配的内存对象缓存系统。用于加速动态web应用程序，减轻数据库负载。
它可以应对任意多个连接，使用非阻塞的网络IO。由于它的工作机制是在内存中开辟一块空间，然后建立一个HashTable，Memcached自管理这些HashTable。
Memcached是简单而强大的。它简单的设计促进迅速部署，易于发展所面临的问题，解决了很多大型数据缓存。它的API可供最流行的语言。
Memcache的知名用户有：LiveJournal、Wikipedia、Flickr、Bebo、Twitter、Typepad、Yellowbot、Youtube 等。
Memcache官方网站：http://memcached.org/
Memcached又是什么？
Memcache是该系统的项目名称，Memcached是该系统的主程序文件，以守护程序方式运行于一个或多个服务器中，随时接受客户端的连接操作，使用共享内存存取数据。
那PHP中的Memcache是什么？
php中的所讲的memcache是用于连接Memecached的客户端组件。
Memcache如何安装？
Memcached 服务端安装：(源码包官方网站下载)
系统命令
1. tar xvf memcached-1.2.6.tar.gz
2. cd memcached-1.2.6
3. ./configure --prefix=/usr/local/memcached
4. make
5. make install
然后就可以启动memcached的守护进程了：
系统命令
1. /usr/local/memcached/bin/memcached -p 11211 -l 127.0.0.1 -d -u nobody -P /var/run/memcached.pid -m 64M -c 1024
几个参数的解释：
-p memcached监听的TCP端口
-l 监听的ip地址，127.0.0.1是本机，当然也可以写上你的服务器IP，如：61.150.91.26，这是我服务器的IP地址，如果你需要多个服务器都能够读取这台memcached的缓存数据，那么就必须设定这个ip
-d 以daemon方式运行，将程序放入后台
-u memcached的运行用户，我设定的是nobody
-P memcached的pid文件路径
-m memcached可以使用的最大内存数量
-c memcached同时可以接受的最大的连接数
如果你希望以socket方式来访问memcached，那么在启动的时候就必须去掉 -l和-p参数，并加上-s参数：
-s memcached的socket文件路径
php中memcache扩展组件的安装：
系统命令
1. tar xvf memcache-3.0.3.tgz
2. cd memcache-3.0.3
3. /usr/local/php5/bin/phpize
4. ./configure --with-php-config=/usr/local/php5/bin/php-config --enable-memcache
5. make
6. make install
按照我的环境，编译出来的memcache.so保存在 /usr/local/php/lib/php/extensions/no-debug-non-zts-20060613/ 目录下，如果你的环境不一样，你得根据自己情况修改你的php.ini了。
接着要做的工作就是让php加载这个扩展，编辑你的php.ini，在适当位置（通常是最后，也可以是独立的一个ini文件）加入如下行：
extension=memcache.so
然后重启你的phpfastcgi进程或者apache，运行一个phpinfo()来确认一下，正常的话你应该可以看到这个了：memcache
php-memcache的简单使用举例：
PHP代码
[code]
1. <?php
2.
3. $memcache = new Memcache;
4. $memcache->connect('127.0.0.1','11211');
5. $memcache->setCompressThreshold(20000, 0.2); // 设置压缩
6. echo $memcache->getVersion(); // 输出memcached版本
7.
8. $test = array(1,2,3,4,5,'abcde'); //生成一个数组
9.
10. if($memcache->get('test')){
11. print_r($memcache->get('test')); //获取数据
12. echo "\n";
13. echo 'cached';
14. echo "\n";
15. }else{
16. $memcache->set('test',$test,0,30); //写入数据
17. echo 'no cache';
18. echo "\n";
19. }
20. ?> [/code]
附：网上有朋友提供的《Memcached 的使用和协议分析详解》
Memcache是一个自由和开放源代码、高性能、分配的内存对象缓存系统。用于加速动态web应用程序，减轻数据库负载。
它可以应对任意多个连接，使用非阻塞的网络IO。由于它的工作机制是在内存中开辟一块空间，然后建立一个HashTable，Memcached自管理这些HashTable。
Memcached是简单而强大的。它简单的设计促进迅速部署，易于发展所面临的问题，解决了很多大型数据缓存。它的API可供最流行的语言。
Memcache的知名用户有：LiveJournal、Wikipedia、Flickr、Bebo、Twitter、Typepad、Yellowbot、Youtube 等。
Memcache官方网站：http://memcached.org/
Memcached又是什么？
Memcache是该系统的项目名称，Memcached是该系统的主程序文件，以守护程序方式运行于一个或多个服务器中，随时接受客户端的连接操作，使用共享内存存取数据。
那PHP中的Memcache是什么？
php中的所讲的memcache是用于连接Memecached的客户端组件。
Memcache如何安装？
Memcached 服务端安装：(源码包官方网站下载)
系统命令
1. tar xvf memcached-1.2.6.tar.gz
2. cd memcached-1.2.6
3. ./configure --prefix=/usr/local/memcached
4. make
5. make install
然后就可以启动memcached的守护进程了：
系统命令
1. /usr/local/memcached/bin/memcached -p 11211 -l 127.0.0.1 -d -u nobody -P /var/run/memcached.pid -m 64M -c 1024
几个参数的解释：
-p memcached监听的TCP端口
-l 监听的ip地址，127.0.0.1是本机，当然也可以写上你的服务器IP，如：61.150.91.26，这是我服务器的IP地址，如果你需要多个服务器都能够读取这台memcached的缓存数据，那么就必须设定这个ip
-d 以daemon方式运行，将程序放入后台
-u memcached的运行用户，我设定的是nobody
-P memcached的pid文件路径
-m memcached可以使用的最大内存数量
-c memcached同时可以接受的最大的连接数
如果你希望以socket方式来访问memcached，那么在启动的时候就必须去掉 -l和-p参数，并加上-s参数：
-s memcached的socket文件路径
php中memcache扩展组件的安装：
系统命令
1. tar xvf memcache-3.0.3.tgz
2. cd memcache-3.0.3
3. /usr/local/php5/bin/phpize
4. ./configure --with-php-config=/usr/local/php5/bin/php-config --enable-memcache
5. make
6. make install
按照我的环境，编译出来的memcache.so保存在 /usr/local/php/lib/php/extensions/no-debug-non-zts-20060613/ 目录下，如果你的环境不一样，你得根据自己情况修改你的php.ini了。
接着要做的工作就是让php加载这个扩展，编辑你的php.ini，在适当位置（通常是最后，也可以是独立的一个ini文件）加入如下行：
extension=memcache.so
然后重启你的phpfastcgi进程或者apache，运行一个phpinfo()来确认一下，正常的话你应该可以看到这个了：memcache
php-memcache的简单使用举例：
PHP代码
[code]
1. <?php
2.
3. $memcache = new Memcache;
4. $memcache->connect('127.0.0.1','11211');
5. $memcache->setCompressThreshold(20000, 0.2); // 设置压缩
6. echo $memcache->getVersion(); // 输出memcached版本
7.
8. $test = array(1,2,3,4,5,'abcde'); //生成一个数组
9.
10. if($memcache->get('test')){
11. print_r($memcache->get('test')); //获取数据
12. echo "\n";
13. echo 'cached';
14. echo "\n";
15. }else{
16. $memcache->set('test',$test,0,30); //写入数据
17. echo 'no cache';
18. echo "\n";
19. }
20. ?> [/code]
附：网上有朋友提供的《Memcached 的使用和协议分析详解》
默认：
httpd.conf 在/etc/httpd/conf
my.cnf 在/etc
php.ini 在/usr/local/lib
在Unix上，php.ini文件缺省放在/usr/local/lib上面，因为缺省的存放路径是<install-path> /lib，但是可以在编译的时候使用--with-config-file-path参数来修改php.ini的存放位置，例如你可以使用--with- config-file-path=/etc把它存放到/etc下面，然后可以从源码包中拷贝php.ini-dist到/etc/php.ini并修改使之满足需要。
Windows上面php.ini的缺省位置是windows系统目录，如果使用了Apache的话，那么将首先从 Apache的安装目录中查找 php.ini，例如：c:program filesapache groupapache，这样你可以在同一台机器上面为不同的Apache版本设置不同的php.ini文件。
httpd.conf 在/etc/httpd/conf
my.cnf 在/etc
php.ini 在/usr/local/lib
在Unix上，php.ini文件缺省放在/usr/local/lib上面，因为缺省的存放路径是<install-path> /lib，但是可以在编译的时候使用--with-config-file-path参数来修改php.ini的存放位置，例如你可以使用--with- config-file-path=/etc把它存放到/etc下面，然后可以从源码包中拷贝php.ini-dist到/etc/php.ini并修改使之满足需要。
Windows上面php.ini的缺省位置是windows系统目录，如果使用了Apache的话，那么将首先从 Apache的安装目录中查找 php.ini，例如：c:program filesapache groupapache，这样你可以在同一台机器上面为不同的Apache版本设置不同的php.ini文件。
负载均衡将是大型网站解决高负荷访问和大量并发请求采用的终极解决办法。
负载均衡技术发展了多年，有很多专业的服务提供商和产品可以选择，我个人接触过一些解决方法，其中有两个架构可以给大家做参考。
硬件四层交换
第四层交换使用第三层和第四层信息包的报头信息，根据应用区间识别业务流，将整个区间段的业务流分配到合适的应用服务器进行处理。 第四层交换功能就象是虚IP，指向物理服务器。它传输的业务服从的协议多种多样，有HTTP、FTP、NFS、Telnet或其他协议。这些业务在物理服务器基础上，需要复杂的载量平衡算法。在IP世界，业务类型由终端TCP或UDP端口地址来决定，在第四层交换中的应用区间则由源端和终端IP地址、TCP和UDP端口共同决定。
在硬件四层交换产品领域，有一些知名的产品可以选择，比如Alteon、F5等，这些产品很昂贵，但是物有所值，能够提供非常优秀的性能和很灵活的管理能力。Yahoo中国当初接近2000台服务器使用了三四台Alteon就搞定了。
软件四层交换
大家知道了硬件四层交换机的原理后，基于OSI模型来实现的软件四层交换也就应运而生，这样的解决方案实现的原理一致，不过性能稍差。但是满足一定量的压力还是游刃有余的，有人说软件实现方式其实更灵活，处理能力完全看你配置的熟悉能力。
软件四层交换我们可以使用Linux上常用的LVS来解决，LVS就是Linux Virtual Server，他提供了基于心跳线heartbeat的实时灾难应对解决方案，提高系统的鲁棒性，同时可供了灵活的虚拟VIP配置和管理功能，可以同时满足多种应用需求，这对于分布式的系统来说必不可少。
一个典型的使用负载均衡的策略就是，在软件或者硬件四层交换的基础上搭建squid集群，这种思路在很多大型网站包括搜索引擎上被采用，这样的架构低成本、高性能还有很强的扩张性，随时往架构里面增减节点都非常容易。这样的架构我准备空了专门详细整理一下和大家探讨。
对于大型网站来说，前面提到的每个方法可能都会被同时使用到，我这里介绍得比较浅显，具体实现过程中很多细节还需要大家慢慢熟悉和体会，有时一个很小的squid参数或者apache参数设置，对于系统性能的影响就会很大，希望大家一起讨论，达到抛砖引玉之效。
阅读全文
负载均衡技术发展了多年，有很多专业的服务提供商和产品可以选择，我个人接触过一些解决方法，其中有两个架构可以给大家做参考。
硬件四层交换
第四层交换使用第三层和第四层信息包的报头信息，根据应用区间识别业务流，将整个区间段的业务流分配到合适的应用服务器进行处理。 第四层交换功能就象是虚IP，指向物理服务器。它传输的业务服从的协议多种多样，有HTTP、FTP、NFS、Telnet或其他协议。这些业务在物理服务器基础上，需要复杂的载量平衡算法。在IP世界，业务类型由终端TCP或UDP端口地址来决定，在第四层交换中的应用区间则由源端和终端IP地址、TCP和UDP端口共同决定。
在硬件四层交换产品领域，有一些知名的产品可以选择，比如Alteon、F5等，这些产品很昂贵，但是物有所值，能够提供非常优秀的性能和很灵活的管理能力。Yahoo中国当初接近2000台服务器使用了三四台Alteon就搞定了。
软件四层交换
大家知道了硬件四层交换机的原理后，基于OSI模型来实现的软件四层交换也就应运而生，这样的解决方案实现的原理一致，不过性能稍差。但是满足一定量的压力还是游刃有余的，有人说软件实现方式其实更灵活，处理能力完全看你配置的熟悉能力。
软件四层交换我们可以使用Linux上常用的LVS来解决，LVS就是Linux Virtual Server，他提供了基于心跳线heartbeat的实时灾难应对解决方案，提高系统的鲁棒性，同时可供了灵活的虚拟VIP配置和管理功能，可以同时满足多种应用需求，这对于分布式的系统来说必不可少。
一个典型的使用负载均衡的策略就是，在软件或者硬件四层交换的基础上搭建squid集群，这种思路在很多大型网站包括搜索引擎上被采用，这样的架构低成本、高性能还有很强的扩张性，随时往架构里面增减节点都非常容易。这样的架构我准备空了专门详细整理一下和大家探讨。
对于大型网站来说，前面提到的每个方法可能都会被同时使用到，我这里介绍得比较浅显，具体实现过程中很多细节还需要大家慢慢熟悉和体会，有时一个很小的squid参数或者apache参数设置，对于系统性能的影响就会很大，希望大家一起讨论，达到抛砖引玉之效。
阅读全文
IT专家网的解释：
“云计算”(Cloud Computing)是分布式处理(Distributed Computing)、并行处理(Parallel Computing)和网格计算(Grid Computing)的发展，或者说是这些计算机科学概念的商业实现。许多跨国信息技术行业的公司如IBM、Yahoo和Google等正在使用云计算的概念兜售自己的产品和服务。
云计算这个名词可能是借用了量子物理中的“电子云”(Electron Cloud)，强调说明计算的弥漫性、无所不在的分布性和社会性特征。量子物理上有“电子云(electron cloud)”，在原子核周围运动的电子不是一个经验世界的轨道例如像天体一样的运行轨道，而是弥漫空间的、云状的存在，描述电子的运动不是牛顿经典力学而是一个概率分布的密度函数，用薛定谔波动方程来描述，特定的时间内粒子位于某个位置的概率有多大，这跟经典力学的提法完全不同。
电子云有以下特性，概然性、弥漫性、同时性等等，云计算可能的确是来自电子云的概念，前今年就有所谓“无所不在的计算”，IBM有一个无所不在的计算叫“Ubiquitous “，MS(Bill)不久也跟着提出一个无所不在的计算“Pervade“，现在人们对无所不在的计算又有了新的认识，现在说是”Omnipresent “。但是，云计算的确不是纯粹的商业炒作，的确会改变信息产业的格局，现在许多人已经用上了Google Doc和Google Apps，用上了许多远程软件应用如Office字处理而不是用自己本地机器上安装这些应用软件，以后谁还会花钱买Office软件呢?还有许多企业应用如电子商务应用，例如要写一个交易程序， Google的企业方案就包含了现成的模板，一个销售人员根本没学习过Netbeanr也能做出来。这种计算和产业动向是符合开源精神的，符合 SaaS(Software as a Service)趋势。
现在有这样的说法，当今世界只有五台计算机，一台是Google的，一台是IBM的，一台是Yahoo的，一台是Amazon的，一台是 Microsoft的，因为这五个公司率先在分布式处理的商业应用上捷足先登引领潮流。Sun公司很早就提出说“网络就是计算机”是有先见之明的。
http://hi.baidu.com/wjtao291/blog/item/1f8fceede9bc304979f05536.html
“云计算”(Cloud Computing)是分布式处理(Distributed Computing)、并行处理(Parallel Computing)和网格计算(Grid Computing)的发展，或者说是这些计算机科学概念的商业实现。许多跨国信息技术行业的公司如IBM、Yahoo和Google等正在使用云计算的概念兜售自己的产品和服务。
云计算这个名词可能是借用了量子物理中的“电子云”(Electron Cloud)，强调说明计算的弥漫性、无所不在的分布性和社会性特征。量子物理上有“电子云(electron cloud)”，在原子核周围运动的电子不是一个经验世界的轨道例如像天体一样的运行轨道，而是弥漫空间的、云状的存在，描述电子的运动不是牛顿经典力学而是一个概率分布的密度函数，用薛定谔波动方程来描述，特定的时间内粒子位于某个位置的概率有多大，这跟经典力学的提法完全不同。
电子云有以下特性，概然性、弥漫性、同时性等等，云计算可能的确是来自电子云的概念，前今年就有所谓“无所不在的计算”，IBM有一个无所不在的计算叫“Ubiquitous “，MS(Bill)不久也跟着提出一个无所不在的计算“Pervade“，现在人们对无所不在的计算又有了新的认识，现在说是”Omnipresent “。但是，云计算的确不是纯粹的商业炒作，的确会改变信息产业的格局，现在许多人已经用上了Google Doc和Google Apps，用上了许多远程软件应用如Office字处理而不是用自己本地机器上安装这些应用软件，以后谁还会花钱买Office软件呢?还有许多企业应用如电子商务应用，例如要写一个交易程序， Google的企业方案就包含了现成的模板，一个销售人员根本没学习过Netbeanr也能做出来。这种计算和产业动向是符合开源精神的，符合 SaaS(Software as a Service)趋势。
现在有这样的说法，当今世界只有五台计算机，一台是Google的，一台是IBM的，一台是Yahoo的，一台是Amazon的，一台是 Microsoft的，因为这五个公司率先在分布式处理的商业应用上捷足先登引领潮流。Sun公司很早就提出说“网络就是计算机”是有先见之明的。
http://hi.baidu.com/wjtao291/blog/item/1f8fceede9bc304979f05536.html
在windows下，一个文件有：创建时间、修改时间、访问时间。
而在Linux下，一个文件也有三种时间，分别是：访问时间、修改时间、状态改动时间。
两者有此不同，在Linux下没有创建时间的概念，也就是不能知道文件的建立时间，但如果文件建立后就没有修改过，修改时间=建立时间;如果文件建立后，状态就没有改动过，那么状态改动时间=建立时间;如果文件建立后，没有被读取过，那么访问时间=建立时间，因为不好判断文件是否被改过、读过、其状态是否变过，所以判断文件的建立时间基本上能为不可能。
如何查一个文件的三个时间呢？
先用下面的命令来建立一个文件
# date && echo "this is file be used test time of file" >filetime.txt && ll --full-time filetime.txt
Tue Aug 4 15:13:44 HKT 2009
-rw-r--r-- 1 root root 39 2009-08-04 15:13:44.000000000 +0800 filetime.txt
通过stat filename.txt来查，如：
# stat filetime.txt
File: `filetime.txt'
Size: 39 Blocks: 8 IO Block: 4096 Regular File
Device: 802h/2050d Inode: 17 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 15:13:44.000000000 +0800
Modify: 2009-08-04 15:13:44.000000000 +0800
Change: 2009-08-04 15:13:44.000000000 +0800
说明：Access访问时间。Modify修改时间。Change状态改动时间。可以stat *查看这个目录所有文件的状态。
ctime=change time
atime=access time
mtime=modifiy time
因为这是一个新的文件（filetime.txt），没做过内容、属性的更改，也没读过这个文件，所以三者（访问时间、修改时间、状态改动时间）的时间是一致的，这时文件的修改时间与这三个时间是一样的，是没有疑问的。
1、访问时间，读一次这个文件的内容，这个时间就会更新。比如对这个文件运用 more、cat等命令。ls、stat命令都不会修改文件的访问时间。
2、修改时间，修改时间是文件内容最后一次被修改时间。比如：vi后保存文件。ls -l列出的时间就是这个时间。
3、状态改动时间。是该文件的i节点最后一次被修改的时间，通过chmod、chown命令修改一次文件属性，这个时间就会更新。
另个除了可以通过stat来查看文件的mtime,ctime,atime等属性，也可以通过ls命令来查看，具体如下:
ls -lc filename 列出文件的 ctime （最后更改时间）
ls -lu filename 列出文件的 atime（最后存取时间）
ls -l filename 列出文件的 mtime （最后修改时间）
在linux中stat函数中，用st_atime表示文件数据最近的存取时间(last accessed time)；用st_mtime表示文件数据最近的修改时间(last modified time)；使用st_ctime表示文件i节点数据最近的修改时间(last i-node's status changed time)。
字段 说明 例子 ls(-l)
st_atime 文件数据的最后存取时间 read -u
st_mtime 文件数据的最后修改时间 write 缺省
st_ctime 文件数据的最后更改时间 chown,chmod -c
在linux系统中，系统把文件内容数据与i节点数据是分别存放的，i节点数据存放了文件权限与文件属主之类的数据。
另外，可以格式化输出文件的三种时间，如：
find . -name file -printf "%AY-%Am-%Ad %AH:%AM:%AS"
find . -name file -printf "%TY-%Tm-%Td %TH:%TM:%TS"
find . -name file -printf "%CY-%Cm-%Cd %CH:%CM:%CS"
linux的ctime代表的是文件修改时间，如果文件被修改过就很难知道文件的创建时间，在某些特殊情况下，需要查看文件的创建时间，正常情况下查看文件的ctime是无法实现的。可以使用一个变通的方法来实现保留文件创建时间，但是同时也会牺牲一些其它特性。
可以在mount文件的时候使用参数-o noatime，来把系统更新atime的特性关闭。使用了noatime参数挂载后，在文件被修改后文件的atime是不会被改变的，使用stat查看到的atime就是文件的创建时间。
如：
# / sbin/mkfs -t ext3 /dev/ram10
# mount -t ext3 -o noatime /dev/loop0 /mnt/foo
# mount
/dev/ram10 on /mnt/foo type ext3 (rw,noatime)
# cd /mnt/foo
# touch filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 0 Blocks: 0 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:51:32.000000000 +0800
Change: 2009-08-04 20:51:32.000000000 +0800
# echo foo.ok >> filetime1.txt
[root@logs-bak foo]# stat filetime1.txt
File: `filetime1.txt'
Size: 14 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:53:27.000000000 +0800
Change: 2009-08-04 20:53:27.000000000 +0800
# cat filetime1.txt
foo.ok
#stat filetime1.txt
File: `filetime1.txt'
Size: 14 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:53:27.000000000 +0800
Change: 2009-08-04 20:53:27.000000000 +0800
# 通过以上实验可以看出文件的access time 是不变的。
接着向下多测试一下.
# vi filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 23 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 14 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:55:05.000000000 +0800
Modify: 2009-08-04 20:55:05.000000000 +0800
Change: 2009-08-04 20:55:05.000000000 +0800
# chmod 777 filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 23 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 14 Links: 1
Access: (0777/-rwxrwxrwx) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:55:05.000000000 +0800
Modify: 2009-08-04 20:55:05.000000000 +0800
Change: 2009-08-04 20:57:36.000000000 +0800
可见，chmod后，Ctime的变化。
#########################################################
说到这里，大概大家也对在linux下文件的时间有所了解了吧！
那么以下的操作对文件的时间有什么影响呢？
操作 atime mtime ctime
----------------------------------------------------------
mv
----------------------------------------------------------
cp
----------------------------------------------------------
touch
----------------------------------------------------------
cat/more/less
----------------------------------------------------------
ls
----------------------------------------------------------
chmod/chown
----------------------------------------------------------
ln
----------------------------------------------------------
echo
----------------------------------------------------------
vi
----------------------------------------------------------
(请大家测试完成这个表吧！！！！做完测试可以给我留言啊！）
##############################################################
另外，从kernel2.6.29开，还默认集成了一个relatime的属性。可能是因为在文件读操作很频繁的系统
中，atime更新所带来的开销很大，所以很多SA都在挂装文件系统的时候使用noatime属性来停止更新atime。但是有些程序需要根据atime进行一些判断和操作，所以Linux就推出了一个relatime特性。
使用这个特性来挂装文件系统后，只有当mtime比atime更新的时候，才会更新atime。事实上，这个时候atime和mtime已经是同一个东西了。所以这个选项就是为了实现对atime的兼容才推出的。并不是一个新的时间属性。使用方法就是通过mount -o relatime /dir来挂装目录。
而在Linux下，一个文件也有三种时间，分别是：访问时间、修改时间、状态改动时间。
两者有此不同，在Linux下没有创建时间的概念，也就是不能知道文件的建立时间，但如果文件建立后就没有修改过，修改时间=建立时间;如果文件建立后，状态就没有改动过，那么状态改动时间=建立时间;如果文件建立后，没有被读取过，那么访问时间=建立时间，因为不好判断文件是否被改过、读过、其状态是否变过，所以判断文件的建立时间基本上能为不可能。
如何查一个文件的三个时间呢？
先用下面的命令来建立一个文件
# date && echo "this is file be used test time of file" >filetime.txt && ll --full-time filetime.txt
Tue Aug 4 15:13:44 HKT 2009
-rw-r--r-- 1 root root 39 2009-08-04 15:13:44.000000000 +0800 filetime.txt
通过stat filename.txt来查，如：
# stat filetime.txt
File: `filetime.txt'
Size: 39 Blocks: 8 IO Block: 4096 Regular File
Device: 802h/2050d Inode: 17 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 15:13:44.000000000 +0800
Modify: 2009-08-04 15:13:44.000000000 +0800
Change: 2009-08-04 15:13:44.000000000 +0800
说明：Access访问时间。Modify修改时间。Change状态改动时间。可以stat *查看这个目录所有文件的状态。
ctime=change time
atime=access time
mtime=modifiy time
因为这是一个新的文件（filetime.txt），没做过内容、属性的更改，也没读过这个文件，所以三者（访问时间、修改时间、状态改动时间）的时间是一致的，这时文件的修改时间与这三个时间是一样的，是没有疑问的。
1、访问时间，读一次这个文件的内容，这个时间就会更新。比如对这个文件运用 more、cat等命令。ls、stat命令都不会修改文件的访问时间。
2、修改时间，修改时间是文件内容最后一次被修改时间。比如：vi后保存文件。ls -l列出的时间就是这个时间。
3、状态改动时间。是该文件的i节点最后一次被修改的时间，通过chmod、chown命令修改一次文件属性，这个时间就会更新。
另个除了可以通过stat来查看文件的mtime,ctime,atime等属性，也可以通过ls命令来查看，具体如下:
ls -lc filename 列出文件的 ctime （最后更改时间）
ls -lu filename 列出文件的 atime（最后存取时间）
ls -l filename 列出文件的 mtime （最后修改时间）
在linux中stat函数中，用st_atime表示文件数据最近的存取时间(last accessed time)；用st_mtime表示文件数据最近的修改时间(last modified time)；使用st_ctime表示文件i节点数据最近的修改时间(last i-node's status changed time)。
字段 说明 例子 ls(-l)
st_atime 文件数据的最后存取时间 read -u
st_mtime 文件数据的最后修改时间 write 缺省
st_ctime 文件数据的最后更改时间 chown,chmod -c
在linux系统中，系统把文件内容数据与i节点数据是分别存放的，i节点数据存放了文件权限与文件属主之类的数据。
另外，可以格式化输出文件的三种时间，如：
find . -name file -printf "%AY-%Am-%Ad %AH:%AM:%AS"
find . -name file -printf "%TY-%Tm-%Td %TH:%TM:%TS"
find . -name file -printf "%CY-%Cm-%Cd %CH:%CM:%CS"
linux的ctime代表的是文件修改时间，如果文件被修改过就很难知道文件的创建时间，在某些特殊情况下，需要查看文件的创建时间，正常情况下查看文件的ctime是无法实现的。可以使用一个变通的方法来实现保留文件创建时间，但是同时也会牺牲一些其它特性。
可以在mount文件的时候使用参数-o noatime，来把系统更新atime的特性关闭。使用了noatime参数挂载后，在文件被修改后文件的atime是不会被改变的，使用stat查看到的atime就是文件的创建时间。
如：
# / sbin/mkfs -t ext3 /dev/ram10
# mount -t ext3 -o noatime /dev/loop0 /mnt/foo
# mount
/dev/ram10 on /mnt/foo type ext3 (rw,noatime)
# cd /mnt/foo
# touch filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 0 Blocks: 0 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:51:32.000000000 +0800
Change: 2009-08-04 20:51:32.000000000 +0800
# echo foo.ok >> filetime1.txt
[root@logs-bak foo]# stat filetime1.txt
File: `filetime1.txt'
Size: 14 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:53:27.000000000 +0800
Change: 2009-08-04 20:53:27.000000000 +0800
# cat filetime1.txt
foo.ok
#stat filetime1.txt
File: `filetime1.txt'
Size: 14 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 12 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:51:32.000000000 +0800
Modify: 2009-08-04 20:53:27.000000000 +0800
Change: 2009-08-04 20:53:27.000000000 +0800
# 通过以上实验可以看出文件的access time 是不变的。
接着向下多测试一下.
# vi filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 23 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 14 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:55:05.000000000 +0800
Modify: 2009-08-04 20:55:05.000000000 +0800
Change: 2009-08-04 20:55:05.000000000 +0800
# chmod 777 filetime1.txt
# stat filetime1.txt
File: `filetime1.txt'
Size: 23 Blocks: 2 IO Block: 4096 Regular File
Device: 10ah/266d Inode: 14 Links: 1
Access: (0777/-rwxrwxrwx) Uid: ( 0/ root) Gid: ( 0/ root)
Access: 2009-08-04 20:55:05.000000000 +0800
Modify: 2009-08-04 20:55:05.000000000 +0800
Change: 2009-08-04 20:57:36.000000000 +0800
可见，chmod后，Ctime的变化。
#########################################################
说到这里，大概大家也对在linux下文件的时间有所了解了吧！
那么以下的操作对文件的时间有什么影响呢？
操作 atime mtime ctime
----------------------------------------------------------
mv
----------------------------------------------------------
cp
----------------------------------------------------------
touch
----------------------------------------------------------
cat/more/less
----------------------------------------------------------
ls
----------------------------------------------------------
chmod/chown
----------------------------------------------------------
ln
----------------------------------------------------------
echo
----------------------------------------------------------
vi
----------------------------------------------------------
(请大家测试完成这个表吧！！！！做完测试可以给我留言啊！）
##############################################################
另外，从kernel2.6.29开，还默认集成了一个relatime的属性。可能是因为在文件读操作很频繁的系统
中，atime更新所带来的开销很大，所以很多SA都在挂装文件系统的时候使用noatime属性来停止更新atime。但是有些程序需要根据atime进行一些判断和操作，所以Linux就推出了一个relatime特性。
使用这个特性来挂装文件系统后，只有当mtime比atime更新的时候，才会更新atime。事实上，这个时候atime和mtime已经是同一个东西了。所以这个选项就是为了实现对atime的兼容才推出的。并不是一个新的时间属性。使用方法就是通过mount -o relatime /dir来挂装目录。
