月度归档：2013年04月

Redis事务学习

资料

一、概述：

和众多其它数据库一样，Redis作为NoSQL数据库也同样提供了事务机制。在Redis中，MULTI/EXEC/DISCARD/WATCH这四个 命令是我们实现事务的基石。相信对有关系型数据库开发经验的开发者而言这一概念并不陌生，即便如此，我们还是会简要的列出Redis中事务的实现特征：
1). 在事务中的所有命令都将会被串行化的顺序执行，事务执行期间，Redis不会再为其它客户端的请求提供任何服务，从而保证了事物中的所有命令被原子的执行。
2). 和关系型数据库中的事务相比，在Redis事务中如果有某一条命令执行失败，其后的命令仍然会被继续执行。
3). 我们可以通过MULTI命令开启一个事务，有关系型数据库开发经验的人可以将其理解为"BEGIN TRANSACTION"语句。在该语句之后执行的命令都将被视为事务之内的操作，最后我们可以通过执行EXEC/DISCARD命令来提交/回滚该事务 内的所有操作。这两个Redis命令可被视为等同于关系型数据库中的COMMIT/ROLLBACK语句。
4). 在事务开启之前，如果客户端与服务器之间出现通讯故障并导致网络断开，其后所有待执行的语句都将不会被服务器执行。然而如果网络中断事件是发生在客户端执行EXEC命令之后，那么该事务中的所有命令都会被服务器执行。
5). 当使用Append-Only模式时，Redis会通过调用系统函数write将该事务内的所有写操作在本次调用中全部写入磁盘。然而如果在写入的过程中 出现系统崩溃，如电源故障导致的宕机，那么此时也许只有部分数据被写入到磁盘，而另外一部分数据却已经丢失。Redis服务器会在重新启动时执行一系列必 要的一致性检测，一旦发现类似问题，就会立即退出并给出相应的错误提示。此时，我们就要充分利用Redis工具包中提供的redis-check-aof 工具，该工具可以帮助我们定位到数据不一致的错误，并将已经写入的部分数据进行回滚。修复之后我们就可以再次重新启动Redis服务器了。

二、相关命令列表：

命令原型时间复杂度命令描述返回值
MULTI用于标记事务的开始，其后执行的命令都将被存入命令队列，直到执行EXEC时，这些命令才会被原子的执行。始终返回OK
EXEC执行在一个事务内命令队列中的所有命令，同时将当前连接的状态恢复为正常状态，即 非事务状态。如果在事务中执行了WATCH命令，那么只有当WATCH所监控的Keys没有被修改的前提下，EXEC命令才能执行事务队列中的所有命令， 否则EXEC将放弃当前事务中的所有命令。原子性的返回事务中各条命令的返回结果。如果在事务中使用了WATCH，一旦事务被放弃，EXEC将返回NULL-multi-bulk回复。
DISCARD回滚事务队列中的所有命令，同时再将当前连接的状态恢复为正常状态，即非事务状态。如果WATCH命令被使用，该命令将UNWATCH所有的Keys。始终返回OK。
WATCH key [key ...]O(1)在MULTI命令执行之前，可以指定待监控的Keys，然而在执行EXEC之前，如果被监控的Keys发生修改，EXEC将放弃执行该事务队列中的所有命令。始终返回OK。
UNWATCHO(1)取消当前事务中指定监控的Keys，如果执行了EXEC或DISCARD命令，则无需再手工执行该命令了，因为在此之后，事务中所有被监控的Keys都将自动取消。始终返回OK。

三、命令示例：

1. 事务被正常执行：
#在Shell命令行下执行Redis的客户端工具。
/> redis-cli
#在当前连接上启动一个新的事务。
redis 127.0.0.1:6379> multi
OK
#执行事务中的第一条命令，从该命令的返回结果可以看出，该命令并没有立即执行，而是存于事务的命令队列。
redis 127.0.0.1:6379> incr t1
QUEUED
#又执行一个新的命令，从结果可以看出，该命令也被存于事务的命令队列。
redis 127.0.0.1:6379> incr t2
QUEUED
#执行事务命令队列中的所有命令，从结果可以看出，队列中命令的结果得到返回。
redis 127.0.0.1:6379> exec
1) (integer) 1
2) (integer) 1

2. 事务中存在失败的命令：
#开启一个新的事务。
redis 127.0.0.1:6379> multi
OK
#设置键a的值为string类型的3。
redis 127.0.0.1:6379> set a 3
QUEUED
#从键a所关联的值的头部弹出元素，由于该值是字符串类型，而lpop命令仅能用于List类型，因此在执行exec命令时，该命令将会失败。
redis 127.0.0.1:6379> lpop a
QUEUED
#再次设置键a的值为字符串4。
redis 127.0.0.1:6379> set a 4
QUEUED
#获取键a的值，以便确认该值是否被事务中的第二个set命令设置成功。
redis 127.0.0.1:6379> get a
QUEUED
#从结果中可以看出，事务中的第二条命令lpop执行失败，而其后的set和get命令均执行成功，这一点是Redis的事务与关系型数据库中的事务之间最为重要的差别。
redis 127.0.0.1:6379> exec
1) OK
2) (error) ERR Operation against a key holding the wrong kind of value
3) OK
4) "4"

3. 回滚事务：
#为键t2设置一个事务执行前的值。
redis 127.0.0.1:6379> set t2 tt
OK
#开启一个事务。
redis 127.0.0.1:6379> multi
OK
#在事务内为该键设置一个新值。
redis 127.0.0.1:6379> set t2 ttnew
QUEUED
#放弃事务。
redis 127.0.0.1:6379> discard
OK
#查看键t2的值，从结果中可以看出该键的值仍为事务开始之前的值。
redis 127.0.0.1:6379> get t2
"tt"

四、WATCH命令和基于CAS的乐观锁：

在Redis的事务中，WATCH命令可用于提供CAS(check-and-set)功能。假设我们通过WATCH命令在事务执行之前监控了多个 Keys，倘若在WATCH之后有任何Key的值发生了变化，EXEC命令执行的事务都将被放弃，同时返回Null multi-bulk应答以通知调用者事务执行失败。例如，我们再次假设Redis中并未提供incr命令来完成键值的原子性递增，如果要实现该功能，我 们只能自行编写相应的代码。其伪码如下：
val = GET mykey
val = val + 1
SET mykey $val
以上代码只有在单连接的情况下才可以保证执行结果是正确的，因为如果在同一时刻有多个客户端在同时执行该段代码，那么就会出现多线程程序中经常出现的一种 错误场景--竞态争用(race condition)。比如，客户端A和B都在同一时刻读取了mykey的原有值，假设该值为10，此后两个客户端又均将该值加一后set回Redis服 务器，这样就会导致mykey的结果为11，而不是我们认为的12。为了解决类似的问题，我们需要借助WATCH命令的帮助，见如下代码：
WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC
和此前代码不同的是，新代码在获取mykey的值之前先通过WATCH命令监控了该键，此后又将set命令包围在事务中，这样就可以有效的保证每个连接在 执行EXEC之前，如果当前连接获取的mykey的值被其它连接的客户端修改，那么当前连接的EXEC命令将执行失败。这样调用者在判断返回值后就可以获 悉val是否被重新设置成功。

PHP5实现多任务并行处理

资料

来源：互联网

HP 开发人员认为，由于标准的 PHP 缺少线程功能，因此实际 PHP 应用程序不可能执行多任务处理。例如，如果应用程序需要其他 Web 站点的信息，那么在远程检索完成之前它都必须停止。这是错误的！通过本文了解如何使用 stream_select 和 stream_socket_client 实现进程内 PHP 多任务处理。

PHP 不支持线程。尽管如此，与前述大多数 PHP 开发人员所相信的想法形成对比的是，PHP 应用程序可以 执行多任务处理。让我们开始尽可能清晰地描述一下 “多任务” 和 “线程” 对于 PHP 编程的意义。

并发的种类

首先抛开几个和主题无关的例子。PHP 与多任务或并发的关系十分复杂。在较高层次上，PHP 经常涉及多任务：以多任务方式使用 标准的服务器端 PHP 安装 —— 例如，作为 Apache 模块。换句话说，若干个客户机 —— Web 浏览器 —— 可以同时请求同一个 PHP 解释的页面，而 Web 服务器将差不多同时返回所有这些页面。

一个 Web 页面不会妨碍其他 Web 页面的发送，尽管可能会由于诸如服务器内存或网络带宽之类的受限资源而使它们相互之间略有妨碍。这样，实现并发 的系统级需求可能适合使用基于 PHP 的解决方案。就实现而言，PHP 允许它的管理 Web 服务器负责实现并发。

Ajax 名下的客户端并发近几年来也已成为开发人员关注的焦点。虽然 Ajax 的含义已经变得十分模糊，但是它的一个方面是浏览器显示可以同时执行计算和 保留对诸如选择菜单项之类的用户操作的响应。这实际上就是某种 多任务。用 PHP 编码的 Ajax 就是这样 —— 但是不涉及任何特定的 PHP；用于其他语言的 Ajax 框架均以完全相同的方法操作。

只粗略地涉及 PHP 的第三个并发实例是 PHP/TK。PHP/TK 是 PHP 的扩展，用于为核心 PHP 提供可移植图形用户界面（GUI）绑定。PHP/TK 允许用 PHP 编写代码构造桌面 GUI 应用程序。其基于事件的特性将模拟一种易于掌握并且比线程更少出错的并发形式。此外，并发是 “继承” 自一项辅助技术，而不是 PHP 的基本功能。

向 PHP 本身添加线程支持的试验已经做过多次。据我所知，没有一次是成功的。但是，Ajax 框架和 PHP/TK 的面向事件的实现表明事件可能比线程能更好地体现 PHP 的并发。PHP V5 证明事实确实如此。

PHP V5 将提供 stream_select()

使用标准的 PHP V4 和更低版本，必须按顺序执行 PHP 应用程序的所有工作。例如，如果程序需要在两个商业站点检索商品的价格，则请求第一个站点的价格，等待至响应到达，再请求第二个站点的价格，然后再次等待。

如果程序请求同时完成若干项任务会怎么样？总体来看，程序将在一段时间内完成，在这段时间内，将始终进行连续处理。

第一个示例

新的 stream_select 函数及它的几个助手使这成为可能。请考虑以下示例。
清单 1. 同时请求多个 HTTP 页面

 

  2.        <?php 
  3. echo "Program starts at ". date('h:i:s') . "./n"; 
  5. $timeout=10; 
  6. $result=array(); 
  7. $sockets=array(); 
  8. $convenient_read_block=8192; 
  10. /* Issue all requests simultaneously; there's no blocking. */
  11. $delay=15; 
  12. $id=0; 
  13. while ($delay > 0) { 
  14. $s=stream_socket_client("phaseit.net:80", $errno, 
  15. $errstr, $timeout, 
  16.                   STREAM_CLIENT_ASYNC_CONNECT|STREAM_CLIENT_CONNECT); 
  17. if ($s) { 
  18. $sockets[$id++]=$s; 
  19. $http_message="GET /demonstration/delay?delay=" . 
  20. $delay . " HTTP/1.0/r/nHost: phaseit.net/r/n/r/n"; 
  21.                 fwrite($s, $http_message); 
  22.             } else { 
  23. echo "Stream " . $id . " failed to open correctly."; 
  24.             } 
  25. $delay -= 3; 
  26.         } 
  28. while (count($sockets)) { 
  29. $read=$sockets; 
  30.             stream_select($read, $w=null, $e=null, $timeout); 
  31. if (count($read)) { 
  32. /* stream_select generally shuffles $read, so we need to
  33.                    compute from which socket(s) we're reading. */
  34. foreach ($read as $r) { 
  35. $id=array_search($r, $sockets); 
  36. $data=fread($r, $convenient_read_block); 
  37. /* A socket is readable either because it has
  38.                        data to read, OR because it's at EOF. */
  39. if (strlen($data) == 0) { 
  40. echo "Stream " . $id . " closes at " . date('h:i:s') . "./n"; 
  41.                         fclose($r); 
  42.                         unset($sockets[$id]); 
  43.                     } else { 
  44. $result[$id] .= $data; 
  45.                     } 
  46.                 } 
  47.             } else { 
  48. /* A time-out means that *all* streams have failed
  49.                    to receive a response. */
  50. echo "Time-out!/n"; 
  51. break; 
  52.             } 
  53.         } 
  54.        ?> 

如果运行此清单，您将看到如下所示的输出。
清单 2. 从清单 1 中的程序获得的典型输出
  Program starts at 02:38:50.
         Stream 4 closes at 02:38:53.
  Stream 3 closes at 02:38:56.
  Stream 2 closes at 02:38:59.
  Stream 1 closes at 02:39:02.
  Stream 0 closes at 02:39:05.
了解这其中的工作原理至关重要。在较高层次上，第一个程序将发出几个 HTTP 请求并接收 Web 服务器发送给它的页面。虽然生产应用程序将很可能寻找若干个 Web 服务器的地址 —— 可能是 google.com、yahoo.com、ask.com 等 —— 但是此示例将把它的所有请求发送到位于 Phaseit.net 的企业服务器上，只为降低复杂度。

Web 页面请求在延迟（可变）后返回结果，如下所示。如果程序按顺序发出请求，则需花费大约 15+12+9+6+3 (45) 秒钟才能完成。如清单 2 所示，它实际上花费 15 秒钟完成。性能提高了三倍。

使这成为可能的是 PHP V5 的新 stream_select 函数。请求都是以常规方法发起，方法为打开几个 stream_socket_client 并向对应于http://phaseit.net/demonstration/delay?delay=$DELAY 的每个 stream_socket_client 写入 GET。如果您通过浏览器请求此 URL，则在几秒钟之后，您将看到：

   Starting at Thu Apr 12 15:05:01 UTC 2007.
   Stopping at Thu Apr 12 15:05:05 UTC 2007.
   4 second delay.
延迟服务器将作为 CGI 实现，如下所示：
清单 3. 延迟服务器实现
   #!/bin/sh

   echo “Content-type: text/html

   <HTML> <HEAD></HEAD> <BODY>”

   echo “Starting at `date`.”
   RR=`echo $REQUEST_URI | sed -e ’s/.*?//’`
   DELAY=`echo $RR | sed -e ’s/delay=//’`
   sleep $DELAY
   echo “<br>Stopping at `date`.”
   echo “<br>$DELAY second delay.</body></html>”
虽然清单 3 的特殊实现特定于 UNIX®，但是本文中几乎所有实现都将很好地应用于 Windows®（尤其是 Windows 98 以后的版本）或 PHP 的 UNIX 安装。特别地，清单 1 可以托管在任意一个操作系统中。因此，Linux® 和 Mac OS X 都是 UNIX 变体，因此这里所有的代码都可以在两者的任意一种中运行。

按照以下顺序向延迟服务器发出请求。
清单 4. 进程启动顺序
delay=15
delay=12
delay= 9
delay= 6
delay= 3
stream_select 的作用是尽可能快速地接收结果。在这种情况下，它执行的顺序与发出结果的顺序刚好相反。3 秒后，第一个页面已经准备好读取。程序的这一部分也符合常规 PHP —— 在本例中，使用 fread。就像在其他 PHP 程序一样，读取可以很好地通过 fgets 完成。

处理将以同样的方法继续。程序将在 stream_select 停止，直至数据就绪。重要的一点是，只要任何 连接具有数据，不管顺序怎样，程序都将开始读取。这是程序进行多任务处理或并发处理来自多个请求的结果的方法。

注意，这没有对主机 CPU 造成任何负担。经常会遇到这样一些连网程序，以 CPU 使用率急速上升至 100% 的方式在 while 中使用 fread。那种情况不会出现在这里，因为 stream_select 拥有支持立即响应所需的属性（只要有任何读取信息），但是它将在各读取操作间隙的等待时间内产生可忽略的 CPU 负载。

必备的 stream_select() 知识

诸如此类的基于事件的编程并不是最基本的。虽然清单 1 被简化到只包含最基本要素，但是涉及作为多任务应用程序必要元素的回调或协调的任何编码，比简单的程序顺序更让人觉得陌生。在这种情况下，大多数挑战集中在 $read 数组上。注意，它是一个引用；stream_select 将通过改变 $read 的内容返回重要信息。就像指针是 C 的最大绊脚石一样，引用似乎是 PHP 中最让程序员感到棘手的一部分。

您可以使用这项技术向任意个外部 Web 站点发出请求，确信您的程序会尽快收到所有结果，而无需等待其他请求。实际上，该技术将正确处理所有 TCP/IP 连接，而不只是 Web 端口 80 上的连接，因此您可以大体上管理 LDAP 检索、SMTP 传输、SOAP 请求等。

但那不是全部。PHP V5 将管理 “流” 之类的各种连接，而不仅是简单的套接字。PHP 的 Client URL library (CURL) 支持 HTTPS 证书、FTP 上传、cookie 等。（CURL 允许 PHP 应用程序使用各种协议连接至服务器）。由于 CURL 将提供流接口，因此从程序的角度来看，连接是透明的。下一个部分将展示 stream_select 如何多路传输本地计算。

对于 stream_select 还有几点需要注意。它还在进行文档整理，因为即使最新的 PHP 书籍都没有涉列它。可在 Web 上获得的几个代码示例完全不能工作或者让人产生混淆。stream_select 的第二个和第三个参数用于管理与清单 1 的 read 通道相对应的 write 和 exception 通道，应当始终为 null。除了少数例外情况，在可写通道或异常通道中选择这两个参数是错误的。除非您有经验，否则请坚持可读选择。

此外，至少在 PHP V5.1.2 之前，stream_select 还明显存在错误。最重要的是，不能信任函数的返回值。虽然我尚未调试过实现，但是经验告诉我，可以安全地测试清单 1 中的 count($read)，但是测试 stream_select 本身的返回值并不 安全（尽管有官方文档）。

本地 PHP 并发

示例及上面的大部分讨论主要讨论了如何同时管理若干个远程资源并接收到达的结果，而不是按照最初请求的顺序等待处理各个请求。这肯定是 PHP 并发的重要应用。实际应用程序的速度有时候可以提高 10 倍或更多。

如果出现性能衰退怎么办？有没有一种方法可以提升受限于本地处理的 PHP 结果的速度？方法有多种。要说有什么不同的话，这些方法不如清单 1 中的面向套接字的方法有名。造成这种情况的原因有很多，包括：

大多数 PHP 页面已经足够快 —— 更好的性能会是一种优势，但是还不值得对新代码进行投入。
在 Web 页面中使用 PHP 可以放弃部分无关紧要的性能提升 —— 当惟一的价值标准是交付整个 Web 页面需要的时间时，那么重新安排计算以更快地获得中间结果并不重要。
PHP 不能控制本地瓶颈 —— 用户可能会为花 8 秒的时间提取帐户记录的详细信息而抱怨，但是那很可能是数据库处理或某种其他 PHP 外部资源的约束。即使将 PHP 处理降至零，单是查找就仍需要花费超过 7 秒的时间。
甚至很少有约束是并行的 —— 假定某特定页面将为具体列出的普通股计算建议交易价格，并且计算十分复杂，需要花费一段时间。计算在本质上可能是顺序执行的。没有一种明显的方法可以将其划分为 “团队协作”。
很少有 PHP 程序员能够认识到 PHP 实现并发的潜力。在具有使用并行实现性能需求的少数人当中，我遇到的大多数人全都说 PHP “不支持线程”，并且甘于使用现有的计算模型。
可是，有时我们可以做得更好。假定 PHP 页面需要计算两只股票价格，可能还需要将两者相比较，并且底层主机刚好是多处理器。在这种情况下，通过将两个截然不同并且十分耗时的计算分配给不同处理器，可能会提高几乎两倍的性能。

在所有 PHP 计算领域中，此类实例很少见。但是，由于我发现到处都没有对它的精确记录，因此需要在这里包括用于此类加速的模型。
清单 5. 延迟服务器实现

复制代码打印?

  2.           <?php 
  3. echo "Program starts at ". date('h:i:s') . "./n"; 
  5. $timeout=10; 
  6. $streams=array(); 
  7. $handles=array(); 
  9. /* First launch a program with a delay of three seconds, then
  10.       one which returns after only one second. */
  11. $delay=3; 
  12. for ($id=0; $id <= 1; $id++) { 
  13. $error_log="/tmp/error" . $id . ".txt"
  14. $descriptorspec=array( 
  15.                   0 => array("pipe", "r"), 
  16.                   1 => array("pipe", "w"), 
  17.                   2 => array("file", $error_log, "w") 
  18.               ); 
  19. $cmd='sleep ' . $delay . '; echo "Finished with delay of ' . 
  20. $delay . '".'; 
  21. $handles[$id]=proc_open($cmd, $descriptorspec, $pipes); 
  22. $streams[$id]=$pipes[1]; 
  23. $all_pipes[$id]=$pipes; 
  24. $delay -= 2; 
  25.           } 
  27. while (count($streams)) { 
  28. $read=$streams; 
  29.               stream_select($read, $w=null, $e=null, $timeout); 
  30. foreach ($read as $r) { 
  31. $id=array_search($r, $strea**ms); 
  32. echo stream_get_contents($all_pipes[$id][1]); 
  33. if (feof($r)) { 
  34.                       fclose($all_pipes[$id][0]); 
  35.                       fclose($all_pipes[$id][1]); 
  36. $return_value=proc_close($handles[$id]); 
  37.                       unset($streams[$id]); 
  38.                   } 
  39.               } 
  40.           } 
  41.          ?> 

此程序将生成如下输出：

   Program starts at 10:28:41.
   Finished with delay of 1.
   Finished with delay of 3.    
这里的关键在于 PHP 启动了两个独立子进程，取回待完成的第一个进程的输出，然后取回第二个进程的输出，即使后者启动得较早。如果主机是多处理器计算机，并且操作系统已正确配置，则操作系统本身负责将各个子程序分配给不同的处理器。这是在多处理器主机中良好应用 PHP 的一种方法。

结束语
PHP 支持多任务。PHP 不按照诸如 Java™ 编程语言或 C++ 等其他语言所采用的方法支持线程，但是以上示例表明 PHP 具有更多的超乎想象的加速潜力。
描述：PHP5 开发多任务应用程序
来源：http://www.ibm.com/developerworks/cn/opensource/os-php-multitask/

解密Redis持久化

资料

本文内容来源于Redis 作者博文，Redis作者说，他看到的所有针对Redis的讨论中，对Redis持久化 的误解是最大的，于是他写了一篇长文 来对Redis的持久化进行了系统性的论述。

什么是持久化，简单来讲就是将数据放到断电后数据不会丢失的设备中。也就是我们通常理解的硬盘上。

写操作的流程

首先我们来看一下数据库在进行写操作时到底做了哪些事，主要有下面五个过程。

  1. 客户端向服务端发送写操作（数据在客户端的内存中）
  2. 数据库服务端接收到写请求的数据（数据在服务端的内存中）
  3. 服务端调用write(2) 这个系统调用，将数据往磁盘上写（数据在系统内存的缓冲区中）
  4. 操作系统将缓冲区中的数据转移到磁盘控制器上（数据在磁盘缓存中）
  5. 磁盘控制器将数据写到磁盘的物理介质中（数据真正落到磁盘上）

写操作大致有上面5个流程，下面我们结合上面的5个流程看一下各种级别的故障。

  • 当数据库系统故障时，这时候系统内核还是OK的，那么此时只要我们执行完了第3步，那么数据就是安全的，因为后续操作系统会来完成后面几步，保证数据最终会落到磁盘上。
  • 当系统断电，这时候上面5项中提到的所有缓存都会失效，并且数据库和操作系统都会停止工作。所以只有当数据在完成第5步后，机器断电才能保证数据不丢失，在上述四步中的数据都会丢失。

通过上面5步的了解，可能我们会希望搞清下面一些问题：

  • 数据库多长时间调用一次write(2)，将数据写到内核缓冲区
  • 内核多长时间会将系统缓冲区中的数据写到磁盘控制器
  • 磁盘控制器又在什么时候把缓存中的数据写到物理介质上

对于第一个问题，通常数据库层面会进行全面控制。而对第二个问题，操作系统有其默认的策略，但是我们也可以通过POSIX API提供的fsync系列命令强制操作系统将数据从内核区写到磁盘控制器上。对于第三个问题，好像数据库已经无法触及，但实际上，大多数情况下磁盘缓存是被设置关闭的。或者是只开启为读缓存，也就是写操作不会进行缓存，直接写到磁盘。建议的做法是仅仅当你的磁盘设备有备用电池时才开启写缓存。

所谓数据损坏，就是数据无法恢复，上面我们讲的都是如何保证数据是确实写到磁盘上去，但是写到磁盘上可能并不意味着数据不会损坏。比如我们可能一次写请求会进行两次不同的写操作，当意外发生时，可能会导致一次写操作安全完成，但是另一次还没有进行。如果数据库的数据文件结构组织不合理，可能就会导致数据完全不能恢复的状况出现。

这里通常也有三种策略来组织数据，以防止数据文件损坏到无法恢复的情况：

  1. 第一种是最粗糙的处理，就是不通过数据的组织形式保证数据的可恢复性。而是通过配置数据同步备份的方式，在数据文件损坏后通过数据备份来进行恢复。实际上MongoDB在不开启journaling日志，通过配置Replica Sets时就是这种情况。
  2. 另一种是在上面基础上添加一个操作日志，每次操作时记一下操作的行为，这样我们可以通过操作日志来进行数据恢复。因为操作日志是顺序追加的方式写的，所以不会出现操作日志也无法恢复的情况。这也类似于MongoDB开启了journaling日志的情况。
  3. 更保险的做法是数据库不进行老数据的修改，只是以追加方式去完成写操作，这样数据本身就是一份日志，这样就永远不会出现数据无法恢复的情况了。实际上CouchDB就是此做法的优秀范例。

RDB快照

下面我们说一下Redis的第一个持久化策略，RDB快照。Redis支持将当前数据的快照存成一个数据文件的持久化机制。而一个持续写入的数据库如何生成快照呢。Redis借助了fork命令的copy on write机制。在生成快照时，将当前进程fork出一个子进程，然后在子进程中循环所有的数据，将数据写成为RDB文件。

我们可以通过Redis的save指令来配置RDB快照生成的时机，比如你可以配置当10分钟以内有100次写入就生成快照，也可以配置当1小时内有1000次写入就生成快照，也可以多个规则一起实施。这些规则的定义就在Redis的配置文件中，你也可以通过Redis的CONFIG SET命令在Redis运行时设置规则，不需要重启Redis。

Redis的RDB文件不会坏掉，因为其写操作是在一个新进程中进行的，当生成一个新的RDB文件时，Redis生成的子进程会先将数据写到一个临时文件中，然后通过原子性rename系统调用将临时文件重命名为RDB文件，这样在任何时候出现故障，Redis的RDB文件都总是可用的。

同时，Redis的RDB文件也是Redis主从同步内部实现中的一环。

但是，我们可以很明显的看到，RDB有他的不足，就是一旦数据库出现问题，那么我们的RDB文件中保存的数据并不是全新的，从上次RDB文件生成到 Redis停机这段时间的数据全部丢掉了。在某些业务下，这是可以忍受的，我们也推荐这些业务使用RDB的方式进行持久化，因为开启RDB的代价并不高。但是对于另外一些对数据安全性要求极高的应用，无法容忍数据丢失的应用，RDB就无能为力了，所以Redis引入了另一个重要的持久化机制：AOF 日志。

AOF日志

aof日志的全称是append only file，从名字上我们就能看出来，它是一个追加写入的日志文件。与一般数据库的binlog不同的是，AOF文件是可识别的纯文本，它的内容就是一个个的Redis标准命令。比如我们进行如下实验，使用Redis2.6版本，在启动命令参数中设置开启aof功能：

./redis-server --appendonly yes

然后我们执行如下的命令：

redis 127.0.0.1:6379> set key1 Hello
OK
redis 127.0.0.1:6379> append key1 " World!"
(integer) 12
redis 127.0.0.1:6379> del key1
(integer) 1
redis 127.0.0.1:6379> del non_existing_key
(integer) 0

这时我们查看AOF日志文件，就会得到如下内容：

$ cat appendonly.aof
*2
$6
SELECT
$1
0
*3
$3
set
$4
key1
$5
Hello
*3
$6
append
$4
key1
$7
 World!
*2
$3
del
$4
key1

可以看到，写操作都生成了一条相应的命令作为日志。其中值得注意的是最后一个del命令，它并没有被记录在AOF日志中，这是因为Redis判断出这个命令不会对当前数据集做出修改。所以不需要记录这个无用的写命令。另外AOF日志也不是完全按客户端的请求来生成日志的，比如命令 INCRBYFLOAT在记AOF日志时就被记成一条SET记录，因为浮点数操作可能在不同的系统上会不同，所以为了避免同一份日志在不同的系统上生成不同的数据集，所以这里只将操作后的结果通过SET来记录。

AOF重写

你可以会想，每一条写命令都生成一条日志，那么AOF文件是不是会很大？答案是肯定的，AOF文件会越来越大，所以Redis又提供了一个功能，叫做AOF rewrite。其功能就是重新生成一份AOF文件，新的AOF文件中一条记录的操作只会有一次，而不像一份老文件那样，可能记录了对同一个值的多次操作。其生成过程和RDB类似，也是fork一个进程，直接遍历数据，写入新的AOF临时文件。在写入新文件的过程中，所有的写操作日志还是会写到原来老的 AOF文件中，同时还会记录在内存缓冲区中。当重完操作完成后，会将所有缓冲区中的日志一次性写入到临时文件中。然后调用原子性的rename命令用新的 AOF文件取代老的AOF文件。

从上面的流程我们能够看到，RDB和AOF操作都是顺序IO操作，性能都很高。而同时在通过RDB文件或者AOF日志进行数据库恢复的时候，也是顺序的读取数据加载到内存中。所以也不会造成磁盘的随机读。

AOF可靠性设置

AOF是一个写文件操作，其目的是将操作日志写到磁盘上，所以它也同样会遇到我们上面说的写操作的5个流程。那么写AOF的操作安全性又有多高呢。实际上这是可以设置的，在Redis中对AOF调用write(2)写入后，何时再调用fsync将其写到磁盘上，通过appendfsync 选项来控制，下面appendfsync的三个设置项，安全强度逐渐变强。

appendfsync no

当设置appendfsync为no的时候，Redis不会主动调用fsync去将AOF日志内容同步到磁盘，所以这一切就完全依赖于操作系统的调试了。对大多数Linux操作系统，是每30秒进行一次fsync，将缓冲区中的数据写到磁盘上。

appendfsync everysec

当设置appendfsync为everysec的时候，Redis会默认每隔一秒进行一次fsync调用，将缓冲区中的数据写到磁盘。但是当这一次的fsync调用时长超过1秒时。Redis会采取延迟fsync的策略，再等一秒钟。也就是在两秒后再进行fsync，这一次的fsync就不管会执行多长时间都会进行。这时候由于在fsync时文件描述符会被阻塞，所以当前的写操作就会阻塞。所以，结论就是，在绝大多数情况下，Redis会每隔一秒进行一次fsync。在最坏的情况下，两秒钟会进行一次fsync操作。

这一操作在大多数数据库系统中被称为group commit，就是组合多次写操作的数据，一次性将日志写到磁盘。

appednfsync always

当设置appendfsync为always时，每一次写操作都会调用一次fsync，这时数据是最安全的，当然，由于每次都会执行fsync，所以其性能也会受到影响。

对于pipelining有什么不同

对于pipelining的操作，其具体过程是客户端一次性发送N个命令，然后等待这N个命令的返回结果被一起返回。通过采用pipilining 就意味着放弃了对每一个命令的返回值确认。由于在这种情况下，N个命令是在同一个执行过程中执行的。所以当设置appendfsync为everysec 时，可能会有一些偏差，因为这N个命令可能执行时间超过1秒甚至2秒。但是可以保证的是，最长时间不会超过这N个命令的执行时间和。

与postgreSQL和MySQL的比较

这一块就不多说了，由于上面操作系统层面的数据安全已经讲了很多，所以其实不同的数据库在实现上都大同小异。总之最后的结论就是，在Redis开启AOF的情况下，其单机数据安全性并不比这些成熟的SQL数据库弱。

这些持久化的数据有什么用，当然是用于重启后的数据恢复。 Redis是一个内存数据库，无论是RDB还是AOF，都只是其保证数据恢复的措施。所以Redis在利用RDB和AOF进行恢复的时候，都会读取RDB或AOF文件，重新加载到内存中。相对于MySQL等数据库的启动时间来说，会长很多，因为MySQL本来是不需要将数据加载到内存中的。

但是相对来说，MySQL启动后提供服务时，其被访问的热数据也会慢慢加载到内存中，通常我们称之为预热，而在预热完成前，其性能都不会太高。而Redis的好处是一次性将数据加载到内存中，一次性预热。这样只要Redis启动完成，那么其提供服务的速度都是非常快的。

而在利用RDB和利用AOF启动上，其启动时间有一些差别。RDB的启动时间会更短，原因有两个，一是RDB文件中每一条数据只有一条记录，不会像 AOF日志那样可能有一条数据的多次操作记录。所以每条数据只需要写一次就行了。另一个原因是RDB文件的存储格式和Redis数据在内存中的编码格式是一致的，不需要再进行数据编码工作。在CPU消耗上要远小于AOF日志的加载。

好了，大概内容就说到这里。更详细完整的版本请看Redis作者的博文：Redis persistence demystified 。本文如有描述不周之处，就大家指正。

由于博客空间在国外，所以有时会造成不稳定（你懂滴），如果您觉得我的博文对您有帮助， 可以点击下面按钮订阅到邮箱，本站所有文章均已全文输出。

 

http://justjavac.com/nosql/2012/04/13/redis-persistence-demystified.html

javadoc注释规范

资料
来源：互联网
javadoc做注释
一. Java 文档// 注释一行
/* ...... */ 注释若干行
/** ...... */ 注释若干行，并写入 javadoc 文档

通常这种注释的多行写法如下：

/**
* .........
* .........
*/

javadoc -d 文档存放目录 -author -version 源文件名.java
这条命令编译一个名为 “源文件名.java”的 java 源文件，并将生成的文档存放在“文档存放目录”指定的目录下，生成的文档中 index.html 就是文档的首页。-author 和 -version 两个选项可以省略。

二. 文档注释的格式

1. 文档和文档注释的格式化

生成的文档是 HTML 格式，而这些 HTML 格式的标识符并不是 javadoc 加的，而是我们在写注释的时候写上去的。
比如，需要换行时，不是敲入一个回车符，而是写入 <br>，如果要分段，就应该在段前写入 <p>。
文档注释的正文并不是直接复制到输出文件 (文档的 HTML 文件)，而是读取每一行后，删掉前导的 * 号及 * 号以前的空格，再输入到文档的。如

/**
* This is first line. <br>
***** This is second line. <br>
This is third line.
*/

2. 文档注释的三部分
先举例如下

/**
* show 方法的简述.
* <p>show 方法的详细说明第一行<br>
* show 方法的详细说明第二行
* @param b true 表示显示，false 表示隐藏
* @return 没有返回值
*/
public void show(boolean b) {
frame.show(b);
}

第一部分是简述。文档中，对于属性和方法都是先有一个列表，然后才在后面一个一个的详细的说明
简述部分写在一段文档注释的最前面，第一个点号 (.) 之前 (包括点号)。换句话说，就是用第一个点号分隔文档注释，之前是简述，之后是第二部分和第三部分。

第二部分是详细说明部分。该部分对属性或者方法进行详细的说明，在格式上没有什么特殊的要求，可以包含若干个点号。
* show 方法的简述.
* <p>show 方法的详细说明第一行<br>
* show 方法的详细说明第二行

简述也在其中。这一点要记住了

第三部分是特殊说明部分。这部分包括版本说明、参数说明、返回值说明等。
* @param b true 表示显示，false 表示隐藏
* @return 没有返回值

三. 使用 javadoc 标记
javadoc 标记由“@”及其后所跟的标记类型和专用注释引用组成
javadoc 标记有如下一些：
@author 标明开发该类模块的作者
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明

@author 作者名
@version 版本号
其中，@author 可以多次使用，以指明多个作者，生成的文档中每个作者之间使用逗号 (,) 隔开。@version 也可以使用多次，只有第一次有效

使用 @param、@return 和 @exception 说明方法
这三个标记都是只用于方法的。@param 描述方法的参数，@return 描述方法的返回值，@exception 描述方法可能抛出的异常。它们的句法如下：
@param 参数名 参数说明
@return 返回值说明
@exception 异常类名 说明

四. javadoc 命令
用法：
javadoc [options] [packagenames] [sourcefiles]

选项：

-public 仅显示 public 类和成员
-protected 显示 protected/public 类和成员 (缺省)
-package 显示 package/protected/public 类和成员
-private 显示所有类和成员
-d <directory> 输出文件的目标目录
-version 包含 @version 段
-author 包含 @author 段
-splitindex 将索引分为每个字母对应一个文件
-windowtitle <text> 文档的浏览器窗口标题

javadoc 编译文档时可以给定包列表，也可以给出源程序文件列表。例如在 CLASSPATH 下有两个包若干类如下：

fancy.Editor
fancy.Test
fancy.editor.ECommand
fancy.editor.EDocument
fancy.editor.EView

可以直接编译类：
javadoc fancy\Test.java fancy\Editor.java fancy\editor\ECommand.java fancy\editor\EDocument.java fancy\editor\EView.java

也可以是给出包名作为编译参数，如：javadoc fancy fancy.editor
可以自己看看这两种方法的区别

到此为止javadoc就简单介绍完了，想要用好她还是要多用，多参考标准java代码
Java代码规范
--注释

@author LEI

@version 1.10 2005-09-01
1 注释文档的格式

注释文档将用来生成HTML格式的代码报告，所以注释文档必须书写在类、域、构造函数、方法、定义之前。注释文档由两部分组成——描述、块标记。

例如：

/**

* The doGet method of the servlet.

* This method is called when a form has its tag value method equals to get.

*

* @param request

* the request send by the client to the server

* @param response

* the response send by the server to the client

* @throws ServletException

* if an error occurred

* @throws IOException

* if an error occurred

*/

public void doGet (HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

doPost(request, response);

}

前两行为描述，描述完毕后，由@符号起头为块标记注视。
2 注释的种类
2.1 文件头注释

文件头注释以 /*开始，以*/结束，需要注明该文件创建时间，文件名，命名空间信息。

例如：

/*

* Created on 2005-7-2

* /
2.2 类、接口注释

类、接口的注释采用 /** … */，描述部分用来书写该类的作用或者相关信息，块标记部分必须注明作者和版本。

例如：

/**Title: XXXX DRIVER 3.0
*Description: XXXX DRIVER 3.0
*Copyright: Copyright (c) 2003
*Company:XXXX有限公司
*
* @author Java Development Group
* @version 3.0
*/

例如：

/**
* A class representing a window on the screen.
* For example:
*
* Window win = new Window(parent);
* win.show();
*
*
* @author Sami Shaio
* @version %I%, %G%
* @see java.awt.BaseWindow
* @see java.awt.Button
*/

class Window extends BaseWindow {

...

}
2.3 构造函数注释

构造函数注释采用 /** … */，描述部分注明构造函数的作用，不一定有块标记部分。

例如：

/**

* 默认构造函数

*/

有例如：

/**

* 带参数构造函数,初始化模式名,名称和数据源类型

*

* @param schema

* Ref 模式名

* @param name

* Ref 名称

* @param type

* byVal 数据源类型

*/
2.4 域注释

域注释可以出现在注释文档里面，也可以不出现在注释文档里面。用/** … */的域注释将会被认为是注释文档热出现在最终生成的HTML报告里面，而使用/* … */的注释会被忽略。

例如：

/* 由于triger和表用一个DMSource，所以要区分和表的迁移成功标记 */

boolean isTrigerSuccess = false;

又例如：

/** 由于triger和表用一个DMSource，所以要区分和表的迁移成功标记 */

boolean isTrigerSuccess = false;

再例如：

/**

* The X-coordinate of the component.

*

* @see #getLocation()

*/

int x = 1263732;

2.5 方法注释

方法注释采用 /** … */，描述部分注明方法的功能，块标记部分注明方法的参数，返回值，异常等信息。例如：

/**

* 设置是否有外码约束

*

* @param conn

* Connection 与数据库的连接

*/
2.6 定义注释

规则同域注释。
3 注释块标记
3.1 标记的顺序

块标记将采用如下顺序：

…

*

* @param (classes, interfaces, methods and constructors only)

* @return (methods only)

* @exception (@throws is a synonym added in Javadoc 1.2)

* @author (classes and interfaces only, required)

* @version (classes and interfaces only, required. See footnote 1)

* @see

* @since

* @serial (or @serialField or @serialData)

* @deprecated (see How and When To Deprecate APIs)

* …

一个块标记可以根据需要重复出现多次，多次出现的标记按照如下顺序：

@author 按照时间先后顺序（chronological）

@param 按照参数定义顺序（declaration）

@throws 按照异常名字的字母顺序（alphabetically）

@see 按照如下顺序：

@see #field

@see #Constructor(Type, Type...)

@see #Constructor(Type id, Type id...)

@see #method(Type, Type,...)

@see #method(Type id, Type, id...)

@see Class

@see Class#field

@see Class#Constructor(Type, Type...)

@see Class#Constructor(Type id, Type id)

@see Class#method(Type, Type,...)

@see Class#method(Type id, Type id,...)

@see package.Class

@see package.Class#field

@see package.Class#Constructor(Type, Type...)

@see package.Class#Constructor(Type id, Type id)

@see package.Class#method(Type, Type,...)

@see package.Class#method(Type id, Type, id)

@see package
3.2 标记介绍
3.2.1 @param标记

@param后面空格后跟着参数的变量名字（不是类型），空格后跟着对该参数的描述。

在描述中第一个名字为该变量的数据类型，表示数据类型的名次前面可以有一个冠词如：a,an,the。如果是int类型的参数则不需要注明数据类型。例如：

…

* @param ch the char 用用来……

* @param _image the image 用来……

* @param _num 一个数字……

…

对于参数的描述如果只是一短语，最好不要首字母大写，结尾也不要句号。

对于参数的描述是一个句子，最好不要首字母大写，如果出现了句号这说明你的描述不止一句话。如果非要首字母大写的话，必须用句号来结束句子。（英文的句号）

公司内部添加ByRef和ByVal两个标记，例如：

* @param _image the image ByRef 用来……

说明该参数是引用传递（指针），ByVal可以省略，表示是值传递。
3.2.2 @return标记

返回为空（void）的构造函数或者函数，@return可以省略。

如果返回值就是输入参数，必须用与输入参数的@param相同的描述信息。

必要的时候注明特殊条件写的返回值。
3.2.3 @throws 标记

@throws以前使用的是@exception。

@throws的内容必须在函数的throws部分定义。
3.2.4 @author标记

类注释标记。

函数注释里面可以不出现@author。
3.2.5 @version

类注释标记。

函数注释里面可以不出现@version
3.2.6 @since

类注释标记。

标明该类可以运行的JDK版本

例如：

@since JDK1.2
3.2.7 @deprecated

由于某种原因而被宣布将要被废弃的方法。

/**

* @deprecated As of JDK 1.1, replaced by

* setBounds

* @see #setBounds(int,int,int,int)

*/
3.2.8 @link标记

语法：{@link package.class#member label}

Label为链接文字。

package.class#member将被自动转换成指向package.class的member文件的URL。
4 HTML代码的使用

在注释描述部分可以使用HTML代码。

…
表示段落

* ….

表示自动标号
5 注释示例

/**

* Graphics is the abstract base class for all graphics contexts

* which allow an application to draw onto components realized on

* various devices or onto off-screen images.

* A Graphics object encapsulates the state information needed

* for the various rendering operations that Java supports. This

* state information includes:

*

# * The Component to draw on

# * A translation origin for rendering and clipping coordinates

# * The current clip

# * The current color

# * The current font

# * The current logical pixel operation function (XOR or Paint)

# * The current XOR alternation color

* (see setXORMode)

*

*

* Coordinates are infinitely thin and lie between the pixels of the

* output device.

* Operations which draw the outline of a figure operate by traversing

* along the infinitely thin path with a pixel-sized pen that hangs

* down and to the right of the anchor point on the path.

* Operations which fill a figure operate by filling the interior

* of the infinitely thin path.

* Operations which render horizontal text render the ascending

* portion of the characters entirely above the baseline coordinate.

*

* Some important points to consider are that drawing a figure that

* covers a given rectangle will occupy one extra row of pixels on

* the right and bottom edges compared to filling a figure that is

* bounded by that same rectangle.

* Also, drawing a horizontal line along the same y coordinate as

* the baseline of a line of text will draw the line entirely below

* the text except for any descenders.

* Both of these properties are due to the pen hanging down and to

* the right from the path that it traverses.

*

* All coordinates which appear as arguments to the methods of this

* Graphics object are considered relative to the translation origin

* of this Graphics object prior to the invocation of the method.

* All rendering operations modify only pixels which lie within the

* area bounded by both the current clip of the graphics context

* and the extents of the Component used to create the Graphics object.

*

* @author Sami Shaio

* @author Arthur van Hoff

* @version %I%, %G%

* @since 1.0

*/

public abstract class Graphics {

/**

* Draws as much of the specified image as is currently available

* with its northwest corner at the specified coordinate (x, y).

* This method will return immediately in all cases, even if the

* entire image has not yet been scaled, dithered and converted

* for the current output device.

*

* If the current output representation is not yet complete then

* the method will return false and the indicated

* {@link ImageObserver} object will be notified as the

* conversion process progresses.

*

* @param img the image to be drawn

* @param x the x-coordinate of the northwest corner

* of the destination rectangle in pixels

* @param y the y-coordinate of the northwest corner

* of the destination rectangle in pixels

* @param observer the image observer to be notified as more

* of the image is converted. May be

* null

* @return true if the image is completely

* loaded and was painted successfully;

* false otherwise.

* @see Image

* @see ImageObserver

* @since 1.0

*/

public abstract boolean drawImage(Image img, int x, int y,

ImageObserver observer);

/**

* Dispose of the system resources used by this graphics context.

* The Graphics context cannot be used after being disposed of.

* While the finalization process of the garbage collector will

* also dispose of the same system resources, due to the number

* of Graphics objects that can be created in short time frames

* it is preferable to manually free the associated resources

* using this method rather than to rely on a finalization

* process which may not happen for a long period of time.

*

* Graphics objects which are provided as arguments to the paint

* and update methods of Components are automatically disposed

* by the system when those methods return. Programmers should,

* for efficiency, call the dispose method when finished using

* a Graphics object only if it was created directly from a

* Component or another Graphics object.

*

* @see #create(int, int, int, int)

* @see #finalize()

* @see Component#getGraphics()

* @see Component#paint(Graphics)

* @see Component#update(Graphics)

* @since 1.0

*/

public abstract void dispose();

/**

* Disposes of this graphics context once it is no longer

* referenced.

*

* @see #dispose()

* @since 1.0

*/

public void finalize() {

dispose();

}

}

花花公园

儿童作品

image

今天天气真好呀， 小朋友们提醒你们一声呀，其实以前来到花花城的小女孩和小男孩都是花花公主和王子，他们今天来到了公园，卡卡她们（他）在水池里面玩水、游泳。果果她们兄妹拿着游泳板在水池里面游泳，有的在浇花，有的在踢球， 还有的在追跑打闹， 卡卡他们用游泳圈在水里游泳。