网络，磁盘IO，内存，CPU四个方面入手，下面案例就是从这四个角度来看。

我们的页面每天PV在30W ，主要是分布在两个主要页面：个人主页，展示主页。假设每个页面各自承担50%的PV，假设访问时间集中在白天8小时，平均下来每秒的请求数是 5.2个，考虑到高峰情况，那么我们就乘以系数20, 就当100个处理，我们最大的一个请求会产生13个processor ,也就是说 最大产生的线程回事 13*100 = 1300。也就是说高峰时刻会有1300个线程需要被处理，我们将队列设置为1000，对于高峰情况就抛弃，因为若是为了满足高峰情况的需要，就会使得部分请求处在队列中，不能充分的利用CPU的资源。

在做压力测试时候，自身应用内部做了小的多线程处理的框架，内部采用的线程池是 SPRING的 ThreadPoolTaskExecutor 的类，通过自身的一个监控框架我们发现，所有的线程单元执行的很快，但是在最后组装processor的时候，花费了时间，在过程中观察CPU的利用率并不是很高。

所以预估是在等待所有线程执行完成时，也就是说有大量的processor在线程池的等待队列中，为了验证是否由于该原因造成的，所以做如下测试：

因为前面提到每秒的平均请求是5.2 考虑到一般的情况，就设置为压测的并发数为 3*5 = 15.

测试案例一：

15线程 

循环100次

线程池：

 corePoolSize ： CPU = 4 

 maxPoolSize  ： 2 * corePoolSize = 8 

 queueCapacity ： 1000 

压测页面： /xxx/22933 

---------------------------------------------- 这个是分割线 ----------------------------------------------

稳定情况下的线程数：

[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 

229

主要是观察，是否充分利用了CPU核数，达到我们预期的效果。现在的服务继承很多框架或是模块后，会启动很多你不知道的线程，在那跑着，时不时跳出来干扰你下，所以一定要等系统运行稳定后观察这个数值。

---------------------------------------------- 这个是分割线 ----------------------------------------------

CPU的一些信息：

[root@host_77-69 ~]# vmstat -ns 3  
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0   2056 723528 392024 1330728    0    0     0     1    1    2  0  0 100  0  0	
 0  0   2056 723404 392024 1330728    0    0     0     0  467  806  0  0 100  0  0	
 0  0   2056 723404 392028 1330728    0    0     0    17  462  807  0  0 100  0  0	
 0  0   2056 723404 392028 1330728    0    0     0     0  457  814  0  0 100  0  0

主要是关注 in ， cs 这两个参数

in：每秒软中断次数

cs: 每秒上下文切换的次数

因为操作系统本身会有一些操作，在未压测前的数值基本在 460 .800 左右。

---------------------------------------------- 这个是分割线 ----------------------------------------------

[root@host_77-69 ~]#  mpstat -P ALL 5 
Linux 2.6.32-71.el6.x86_64 (host_77-69) 	09/12/2012 	_x86_64_	(4 CPU)

02:04:21 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
02:04:26 PM  all    0.10    0.00    0.00    0.00    0.00    0.00    0.00    0.00   99.90
02:04:26 PM    0    0.20    0.00    0.00    0.00    0.00    0.00    0.00    0.00   99.80

关注soft 这个参数 这个代表当前CPU在所有时间中，用于切换上下所化时间比,若是花费的越多，代表当前的线程切换过于频繁，没有充分利用CPU，建议减少线程数或是增加CPU。

user 、 nice、sys主要是观察系统中是否存在大量计算，或是死循环的情况，来消耗大量的CPU。

这个命令是对于vmstat的补充，更直观的观察CPU的上下文切换及软中断情况。

---------------------------------------------- 下面是内存的初始情况了 ----------------------------------------------

JVM自身的内存情况：

[root@host_77-69 ~]# jstat -gcutil `jps | grep -i main | awk '{print $1}'` 3000 1000 
  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT   
  0.00   0.00  90.91  13.56  60.25     26    0.877     2    0.802    1.679
  0.00   0.00  91.17  13.56  60.25     26    0.877     2    0.802    1.679
  0.00   0.00  91.27  13.56  60.25     26    0.877     2    0.802    1.679
  0.00   0.00  91.28  13.56  60.25     26    0.877     2    0.802    1.679

fugcc次数基本不变，而且各个代内存变化基本不大 

操作系统的内存情况：

[root@host_77-69 releases]# for i in {1..10};do  free;sleep 3  ; done;
             total       used       free     shared    buffers     cached
Mem:       3925596    3223996     701600          0     392352    1330896
-/+ buffers/cache:    1500748    2424848
Swap:      4194296       2056    4192240
             total       used       free     shared    buffers     cached
Mem:       3925596    3223996     701600          0     392352    1330896
-/+ buffers/cache:    1500748    2424848
Swap:      4194296       2056    4192240
             total       used       free     shared    buffers     cached
Mem:       3925596    3223996     701600          0     392352    1330896
-/+ buffers/cache:    1500748    2424848
Swap:      4194296       2056    4192240

数值也基本保持不变化

---------------------------------------------- 下面是磁盘IO的初始情况了 ---------------------------------------------- 

[root@host_77-69 ~]# for i in {1..10};do  iostat ; sleep 3 ; done ;
Linux 2.6.32-71.el6.x86_64 (host_77-69) 	09/12/2012 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           0.10    0.00    0.02    0.00    0.00   99.88

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.31         0.33         5.93    1751462   31740872

Linux 2.6.32-71.el6.x86_64 (host_77-69) 	09/12/2012 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           0.10    0.00    0.02    0.00    0.00   99.88

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.31         0.33         5.93    1751462   31740960

主要观察 

Blk_read/s    每秒中读取的块数

Blk_wrtn/s    每秒中写的块数

%iowait       当前在等待磁盘IO的情况

---------------------------------------------- 说了这么多终于要开始了 ---------------------------------------------- 

开始压测后，得到下面的数据：

[root@host_77-69 ~]# vmstat -ns 3  
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
0  0   2056 698224 393212 1331344    0    0     0     3  536  867  0  0 100  0  0	
 3  0   2056 694796 393212 1332248    0    0     0    19 7170 7515 55  4 40  0  0	
 1  0   2056 694796 393212 1333132    0    0     0     4 7121 7627 50  5 45  0  0	
 4  0   2056 692936 393216 1334376    0    0     0    17 6478 8738 54  5 42  0  0	
 2  0   2056 691548 393232 1335620    0    0     0    25 6497 7663 48  4 48  0  0	
 5  0   2056 689936 393232 1337052    0    0     0     3 7597 7174 47  5 48  0  0	
 3  0   2056 688704 393232 1338496    0    0     0    12 7369 8774 49  5 45  0  0	
 3  0   2056 686348 393232 1341528    0    0     0   819 12298 16011 50  5 45  0  0	
 4  0   2056 684976 393236 1343020    0    0     0    12 6034 6951 48  4 48  0  0	
 3  0   2056 664268 393240 1344508    0    0     0     1 6731 9584 52  5 42  0  0	
 1  0   2056 659360 393240 1346284    0    0     0    12 7797 8431 54  5 41  0  0	
 2  0   2056 657624 393240 1347564    0    0     0  2684 6908 7656 50  5 45  0  0	

在压测的这个过程中，CPU大量上下文切换动作明显增加了很多。

[root@host_77-69 ~]#  mpstat -P ALL 5 
 04:01:32 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
04:01:37 PM  all    0.15    0.00    0.10    0.00    0.00    0.05    0.00    0.00   99.70
04:01:37 PM    0    0.20    0.00    0.00    0.00    0.00    0.20    0.00    0.00   99.60
04:01:37 PM    1    0.20    0.00    0.00    0.00    0.00    0.00    0.00    0.00   99.80
04:01:37 PM    2    0.20    0.00    0.00    0.00    0.00    0.00    0.00    0.00   99.80
04:01:37 PM    3    0.00    0.00    0.00    0.00    0.00    0.00    0.00    0.00  100.00

这个数据上看出其中一个CPU花费在切换的时间比是0.2%，也不是很高。

 [root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
229
[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
236
[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
236
[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
235
[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
229
[root@host_77-69 ~]# ps -eLf | grep java  | wc -l 
229

java的线程数增加到了236，也就是说增加了7个，我们最初设置是4个，队列1000 ，在队列满了后，增加了3个，也就是说，这种情况，扩容到7个线程，就能满足我们的压测条件，那说明core为4，存在大量的队列积压情况，同时，上面的数据表明，用于上下文切换的比例也不是很高，如此我们就可以增加线程池的corePoolSize。那么下个案例就可以设置为8个试试看。

[root@host_77-69 ~]# jstat -gcutil `jps | grep -i main | awk '{print $1}'` 3000 1000 
  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT   
 0.00  27.46  76.94  19.37  60.86     31    1.139     3    1.497    2.636
  0.00  23.34  85.64  19.37  60.90     33    1.150     3    1.497    2.647
  0.00  36.14  38.44  19.37  60.91     35    1.167     3    1.497    2.665
  0.00  63.19  37.87  19.37  60.92     37    1.191     3    1.497    2.688
 59.29   0.00   1.61  19.48  60.92     40    1.226     3    1.497    2.723
  0.00  50.63  58.22  19.50  60.93     41    1.236     3    1.497    2.733
  0.00  51.09  70.36  19.58  60.94     43    1.265     3    1.497    2.762
 44.05   0.00   2.09  19.67  60.95     46    1.298     3    1.497    2.795
  0.00  83.74  75.70  19.68  60.96     47    1.316     3    1.497    2.813
  0.00  89.57  77.32  20.21  60.96     49    1.350     3    1.497    2.847
 46.02   0.00  36.83  22.12  60.97     52    1.399     3    1.497    2.896
 36.69   0.00  37.78  22.12  60.98     54    1.417     3    1.497    2.914
 59.51   0.00  23.47  22.12  61.00     56    1.435     3    1.497    2.932
 64.53   0.00  36.51  22.29  61.03     58    1.461     3    1.497    2.959
 73.19   0.00  78.00  23.01  61.05     60    1.497     3    1.497    2.995
 54.24   0.00  36.10  23.01  61.06     62    1.521     3    1.497    3.018
 79.36   0.00  82.65  23.01  61.08     64    1.547     3    1.497    3.044
  0.00  68.75  48.34  26.61  61.10     67    1.606     3    1.497    3.103
 29.33   0.00  93.75  26.61  61.12     68    1.613     3    1.497    3.110
  0.00  45.32  23.68  26.61  61.12     71    1.640     3    1.497    3.138
 34.93   0.00  19.75  29.84  61.13     74    1.697     3    1.497    3.194
 22.59   0.00  27.47  29.84  61.14     76    1.711     3    1.497    3.208
 54.40   0.00  74.16  30.45  61.15     78    1.734     3    1.497    3.231
 25.23   0.00  77.50  30.45  61.15     80    1.747     3    1.497    3.245
 25.23   0.00  98.39  30.45  61.15     80    1.747     3    1.497    3.245
 25.23   0.00  99.94  30.45  61.15     80    1.747     3    1.497    3.245
  0.00  14.32   1.42  30.45  61.15     81    1.752     3    1.497    3.250
  0.00  14.32   2.15  30.45  61.15     81    1.752     3    1.497    3.250
  0.00  14.32   2.27  30.45  61.15     81    1.752     3    1.497    3.250
  0.00  14.32   2.48  30.45  61.15     81    1.752     3    1.497    3.250

这个是查看JVM的GC情况的，数据表明，压测期间，ygc还是蛮频繁，但是每次ygc后进入old区的数据并不是很多，说明我们的应用大部分是朝生夕死，并不会发生频繁fgc的情况，之后就不用把重心放在JVM的GC上。

[root@host_77-69 releases]# for i in {1..10};do  free;sleep 3  ; done;
             total       used       free     shared    buffers     cached
Mem:       3925596    3370968     554628          0     395584    1369572
-/+ buffers/cache:    1605812    2319784
Swap:      4194296       2056    4192240

操作系统跟之心前相比，基本没有发生任何的改变。

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           0.10    0.00    0.02    0.00    0.00   99.88

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.31         0.33         5.95    1751462   31823032

Linux 2.6.32-71.el6.x86_64 (host_77-69) 	09/12/2012 	_x86_64_	(4 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           0.10    0.00    0.02    0.00    0.00   99.88

Device:            tps   Blk_read/s   Blk_wrtn/s   Blk_read   Blk_wrtn
sda               0.31         0.33         5.95    1751462   31823032

这个是当前应用对于磁盘的消耗情况，对比初始值，基本没什么变化，可以看出我们这个应用没有磁盘IO的消耗，这说明本应用并没有大量的操作本地磁盘IO情况。

这个也不是导致我们系统慢的原因，也可以排除。

xxxModuleProcessor 33 最慢的processor是33毫秒

我们的processor最大的消耗是33毫秒，外部调用4.9ms ，但是最后看到的消耗时间是557ms，且上面的情况说明了，存在大量队列积压，我们的数据处理processor都在等待队列了

下面是我们通过

Avg(ms):

第一次： 662.5 毫秒

第二次： 680   毫秒

第三次： 690   毫秒

通过上面的分析，平均响应时间是：680ms,基本可以确定问题在于线程池corePoolSize过小,导致了一定的数据在队列中积压。

---------------------------------------------  这是一条伟大的分割线  ---------------------------------------------

测试案例二：

改动：增加一倍的corePoolSize

15线程 

循环100次

线程池：

 corePoolSize ；2 * CPU =  8 

 maxPoolSize  ：2 * corePoolSize = 16 

 queueCapacity ： 1000 

压测页面： /member/22933 

---------------------------------------------  我又出现了  ---------------------------------------------

再次启动稳定后：

[root@host_77-69 ~]# for i in {1..10000};do    ps -eLf | grep java  | wc -l; echo "-------" ; sleep 2 ; done;

215

-------

215

-------

215

-------

java的线程数维持在215个，跟上面有点不同，当然不管了，这个不是重点。

[root@host_77-69 ~]# vmstat -ns 3  
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
 0  0   2056 933420 395768 1341376    0    0     0     8  579  875  0  0 100  0  0	
 0  0   2056 933420 395768 1341376    0    0     0     3  579  860  0  0 100  0  0	
 0  0   2056 933420 395776 1341372    0    0     0     9  568  867  0  0 100  0  0	

初始情况CPU运行都很正常 

[root@host_77-69 ~]#  mpstat -P ALL 5 
Linux 2.6.32-71.el6.x86_64 (host_77-69) 	09/12/2012 	_x86_64_	(4 CPU)

05:43:34 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:43:39 PM  all    0.40    0.00    0.10    0.00    0.00    0.00    0.00    0.00   99.50
05:43:39 PM    0    0.80    0.00    0.20    0.00    0.00    0.00    0.00    0.00   99.00

基本没有软中断

压测后得到如下数据：

[root@host_77-69 ~]# for i in {1..10000};do    ps -eLf | grep java  | wc -l; echo "-------" ; sleep 2 ; done;

214

-------

214

-------

214

-------

217

-------

219

-------

219

-------

。。。。。。

221

-------

219

-------

。。。。。。

218

-------

218

-------

214

-------

这个java线程数的变化情况，从 214-- 221 -- 214。 初始化了8个，然后增加了7个，也就是说线程池中总共启用了15个线程。

------------------------------------------------------  

[root@host_77-69 ~]#  mpstat -P ALL 5 
05:59:00 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:59:05 PM  all   51.46    0.00    4.58    0.00    0.29    2.00    0.00    0.00   41.67
05:59:05 PM    0   50.98    0.00    4.71    0.00    0.98    7.25    0.00    0.00   36.08
05:59:05 PM    1   51.07    0.00    4.29    0.00    0.00    0.39    0.00    0.00   44.25
05:59:05 PM    2   50.49    0.00    4.87    0.00    0.00    0.19    0.00    0.00   44.44
05:59:05 PM    3   53.29    0.00    4.46    0.00    0.00    0.19    0.00    0.00   42.05

05:59:05 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:59:10 PM  all   49.56    0.00    4.25    0.00    0.29    2.00    0.00    0.00   43.89
05:59:10 PM    0   46.56    0.00    3.73    0.00    1.18    7.07    0.00    0.00   41.45
05:59:10 PM    1   58.12    0.00    4.31    0.00    0.00    0.39    0.00    0.00   37.18
05:59:10 PM    2   45.72    0.00    4.67    0.00    0.00    0.39    0.00    0.00   49.22
05:59:10 PM    3   47.95    0.00    4.29    0.00    0.00    0.39    0.00    0.00   47.37

05:59:10 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:59:15 PM  all   50.54    0.00    4.19    0.00    0.29    1.75    0.00    0.00   43.23
05:59:15 PM    0   55.36    0.00    3.70    0.00    1.17    5.85    0.00    0.00   33.92
05:59:15 PM    1   53.62    0.00    4.70    0.00    0.00    0.59    0.00    0.00   41.10
05:59:15 PM    2   46.98    0.00    4.29    0.00    0.00    0.19    0.00    0.00   48.54
05:59:15 PM    3   46.21    0.00    4.27    0.00    0.00    0.19    0.00    0.00   49.32

05:59:15 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:59:20 PM  all   52.78    0.00    4.48    0.05    0.39    2.14    0.00    0.00   40.17
05:59:20 PM    0   52.17    0.00    3.94    0.00    1.57    7.68    0.00    0.00   34.65
05:59:20 PM    1   52.35    0.00    4.90    0.00    0.00    0.39    0.00    0.00   42.35
05:59:20 PM    2   57.09    0.00    4.85    0.00    0.00    0.19    0.00    0.00   37.86
05:59:20 PM    3   49.42    0.00    4.23    0.00    0.00    0.38    0.00    0.00   45.96

05:59:20 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
05:59:25 PM  all   46.90    0.00    3.85    0.00    0.34    1.76    0.00    0.00   47.15
05:59:25 PM    0   48.34    0.00    3.70    0.00    1.56    6.43    0.00    0.00   39.96
05:59:25 PM    1   43.30    0.00    4.47    0.00    0.00    0.39    0.00    0.00   51.84
05:59:25 PM    2   50.59    0.00    3.52    0.00    0.00    0.39    0.00    0.00   45.51
05:59:25 PM    3   45.14    0.00    3.70    0.00    0.00    0.19    0.00    0.00   50.97

上面的数据表明，中断占CPU的比例确大大增加了。单核中断最高达到了7.25% 如此导致了什么结果呢?

Min(ms) Max(ms) Avg(ms) 95Line(ms) Std(ms) TPS

161.2  8877.4 731.7  1000.0    65.3  1.2

想比较corePoolSize:4 max:8 性能反而下降了。平均响应时间从662.5降到了731.7。

最慢的processor的消耗时间是： 187.9

期间也猜测可能是其中一个服务被我们压坏了，就重启了那个服务，再次压测的结果是

Min(ms) Max(ms) Avg(ms) 95Line(ms) Std(ms) TPS

102.9  9188.9 762.5  1095.0    657.8  3.0

平均响应时间是：750毫秒左右。

也就是说，基本可以确认是由于我们增加了 coreSize和maxSize导致性能变慢了。慢了近80毫秒。说明过多的CPU并不会加快我们的处理速度。

如此就有了下面的方案。

测试方案三：

corePoolSize : cpu数量 + 1  = 5 

maxPoolSzie : 2 *　corePoolSize　 = 10 

我们看下具体情况吧：

[root@host_77-69 ~]#  mpstat -P ALL 5 
06:57:36 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
06:57:41 PM  all   58.27    0.00    5.38    0.00    0.49    2.30    0.00    0.00   33.56
06:57:41 PM    0   61.66    0.00    4.74    0.00    1.98    8.10    0.00    0.00   23.52
06:57:41 PM    1   55.75    0.00    5.65    0.00    0.00    0.58    0.00    0.00   38.01
06:57:41 PM    2   57.81    0.00    5.47    0.00    0.00    0.20    0.00    0.00   36.52

CPU的上下文切换还是很厉害。达到了8.10%

[root@host_77-69 ~]# for i in {1..10000};do    ps -eLf | grep java  | wc -l; echo "-------" ; sleep 2 ; done;

214

-------

214

-------

219

-------

219

-------

217

-------

215

-------

214

214--219 

原来线程池core是5，我们最大是10个，线程数确实增加到了10个，就是说10个线程对应到4个CPU上，两者的比例是1:2.25 

结果：

第一次压测是：648毫秒

第二次压测是：622毫秒

第三次压测是：603毫秒

就取中间值吧：622毫秒 

性能想比较 core：8 max:16的话，有0.060毫秒的提升。说明一定cpu和进程数保持在1:2.25的比例上，效率上还是有提高的，但是上下文切换的还是很厉害。

为了不让它切换的这么厉害，就将max设置的小点吧。

测试方案四

线程：15 

循环：100次

corePoolSize : cpu数量 + 1    =  5 

maxPoolSzie : 2 * cpu    =  8

08:13:13 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
08:13:18 PM  all   52.45    0.00    4.60    0.00    0.10    1.27    0.00    0.00   41.58
08:13:18 PM    0   60.00    0.00    3.96    0.00    0.59    3.96    0.00    0.00   31.49
08:13:18 PM    1   50.29    0.00    5.48    0.00    0.00    0.20    0.00    0.00   44.03
08:13:18 PM    2   50.78    0.00    4.86    0.00    0.00    0.58    0.00    0.00   43.77
08:13:18 PM    3   48.83    0.00    4.28    0.00    0.00    0.19    0.00    0.00   46.69

08:13:18 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
08:13:23 PM  all   50.05    0.00    4.29    0.00    0.10    1.22    0.00    0.00   44.34
08:13:23 PM    0   57.54    0.00    4.56    0.00    0.20    3.97    0.00    0.00   33.73
08:13:23 PM    1   49.81    0.00    4.28    0.00    0.00    0.39    0.00    0.00   45.53
08:13:23 PM    2   48.16    0.00    3.88    0.00    0.00    0.39    0.00    0.00   47.57
08:13:23 PM    3   45.07    0.00    4.45    0.00    0.00    0.19    0.00    0.00   50.29

08:13:23 PM  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest   %idle
08:13:28 PM  all   51.34    0.00    4.69    0.00    0.10    1.27    0.00    0.00   42.60
08:13:28 PM    0   60.08    0.00    4.15    0.00    0.40    3.95    0.00    0.00   31.42
08:13:28 PM    1   47.75    0.00    6.07    0.00    0.00    0.39    0.00    0.00   45.79
08:13:28 PM    2   47.48    0.00    4.26    0.00    0.00    0.39    0.00    0.00   47.87
08:13:28 PM    3   50.19    0.00    4.28    0.00    0.00    0.39    0.00    0.00   45.14

中断时间确实从7%下降到了4%左右。

[root@host_77-69 ~]# for i in {1..10000};do    ps -eLf | grep java  | wc -l; echo "-------" ; sleep 2 ; done;

215

-------

217

-------

217

-------

219

-------

219

-------

218

-------

线程池基本处于饱和状态。

结果：

第一次压测结果：629毫秒

第二次压测结果：618毫秒

第三次压测结果：586毫秒

这次CPU:线程数为1:2

相比较CPU和线程数1.2.25的结果有稍微的提升，因为CPU中断时间比下降了。

最终的结论，JVM的垃圾回收，本地磁盘IO，操作系统内存都不会对本应用产生影响，唯一的元素就是线程池大小的设置。目前测试出来的最佳策略是：

corePoolSize = cpu + 1

maxPoolSize = 2 *　 cpu  　

• —软件人才免语言低担保 赴美带薪读研！—

AOP 的简单入门

自己也算是从业多年，对于AOP的概念应该算是听的烂的不能再烂了，这方面的书也看的不少，但是自己一直没有机会去实践下。

乘在这个稍微有点空闲的下午，就随手玩玩SPRING的AOP，也谈谈自己对于AOP的理解及其衍生的一些东西。

1.一切术语都是纸老虎

基本概念，也可以说是基本术语。任何一个软件概念提出时候，都少不了这个东西。CRM,AOP,SOA等等，伴随这些东西的都会有相应体系内的术语。

我个人的看法是一切术语的出现不是并不是向大众解释清楚这件事到底是怎么一回事，其主要是基于两个方面考虑：

1.让自己提出观点显得系统化，更具有说服力。

2.迷惑大众，或是迷糊那些刚进入这个领域的初学者。

两个看似矛盾的因素，其实归结到本质就是将一个简单的东西复杂化并迷糊那些辨别能力的一般的人，大家对于抽象到一定程度的东西但是心怀敬畏之心的，然后带着膜拜的心理去接受，生怕一不小心亵渎了内心的女神。扯开来讲现在社会，官员的道德沦丧，其中的一个诱因就是对于敬畏之心的缺失，当一个人无所畏时，才是最可怕的，因为这个时候已经没有任何约束能约束他的行为。

回归正题，既然提到术语，那么我们就将AOP中的那些术语列出来看看。

切面（Aspect）、连接点（Joinpoint）、通知（Advice）、切入点（Pointcut） 、目标对象（Target Object）、AOP代理（AOP Proxy）。

通知又分为几种：前置通知（Before advice）、后通知（After advice）、返回后通知（After return advice）、环绕通知（Around advice）、抛出异常后通知（After throwing advice） 等。

好了，现在我们来看看这些术语，谁能一眼就明白这些东西能告诉我们什么？谁能通畅的理清楚它们之间的关系。开始解释之前，我们看看维基百科上对AOP的定义是什么：

面向侧面的程序设计（aspect-oriented programming，AOP，又译作面向方面的程序设计、觀點導向編程）是计算机科学中的一个术语，指一种程序设计范型。该范型以一种称为侧面（aspect，又译作方面）的语言构造为基础，侧面是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。

多么简单的解释，就是对于那些在主程序业务之外的事情，我们该怎么设计，看清楚，是程序设计，而不是程序编码，很多地方都将AOP理解成面向切面的编码，那是错误，AOP约定的是一种设计范型，具体到java上的实现例如aspectJ,例如spring的AOP。再具体到实现技术就是JDK自带的动态代理，cglib的字节码修改等等。AOP != spring AOP ,AOP != cglib 。一个是设计范型，一个是实现。

(这里扯开点说，一些所谓的架构师喜欢谈概念，还有人提出架构师更关注抽象的东西，普通的码农更关注具象的东西。这些东西本身没错，在大量的实践之后，我们确实应该去在这大量的实践中归纳，总结出规律，这就是进行抽象。但是，但是，那些只跟你扯抽象而不落地的架构师，还是远离些，因为他们不是基于大量的具象后，进行抽象，他们不过是邯郸学步的抄袭那些真正的架构师的想法，并转变为自己的观点，TMD就是个大忽悠)

2.那些主程序之外的杂事

我们知道，一个程序是会被编译成计算机能识别的机器码，交给机器去执行，那么我们想知道机器在执行我们的代码时候，发生的一些事，例如：

1. 一个输入是否得到我们想要的输出呢？
2. 一个函数执行的时间开销是多少呢？
3. 若是一个良好的程序遇到无法处理的异常我们该怎么办呢？
4. 存在多个数据源，我们需要在多个数据源的更新都完成后，再提交该怎么处理呢？
5. 我们想将一些我们不认可的请求拒绝，那又该怎么处理呢？

当以上的这些杂事出现时，我们该怎么做呢，一种很简单粗暴的方式就是硬编码的将这些杂事写入到我们的主要业务程序中，我想这种方式大家在日常的开发经常能看到，包括你去看一些所谓平台级别的产品也是采用这种方式，笔者现在所在单位的部分产品也是如此。不管你爽不爽，老子爽了就可以了。

3.上吧，骚年

用个不恰当的比喻来说：你是个开饭店的，来了很多顾客，当你女服务员在招待顾客时，你突然发现XX院长来了，想来OOXX下。你就定了一个流程，来XX院长，可OOXX，硬编码的方式就是：

1.你女服务员在招待

2.XX院长跟她OOXX

3.你女服务员在招待

4.屌丝来了，无视之

......

这个过程中你不管你女服务员是否来例假，你不关心你女服务员是否今天心情不好。嗯，院长爽了，若是你得到了某种回报，也还好，爽了；若是什么都得不到，那可就欲哭无泪。

如果你足够幸福的话，有另一个口味美女服务员，她会隐藏技能---洗脚。恰巧经管学院院长也来了，这个家伙还喜欢洗脚，那怎么办，那就上吧：

1.你女服务员在招待

2.XX院长跟她OOXX+洗脚

3.你女服务员在招待

4.屌丝来了，无视之

......

如果你生意足够好，恰好XX院长又很多，好吧，你的美女们一直处在XXOO状态中..... 很high，很happy。但是，我们回到最开始，你为什么要招女服务员？找她们来，是因为你需要她们去招待顾客，一个屌丝在等吃饭没关系，若是一群的屌丝在等吃饭，你就悲剧，没人招待屌丝们了，因为你的那些服务员都在跟院长们OOXX中，因为命令已经固化到流程中，你改不了，至少在你修改流程之前。通过我们软件术语来说，就是不能及时、灵活的应对自身内部(你的美女们身体、心情)和外部(屌丝数量)的变化。当然， 你若是铁道部这样的共和国长子，那是没关系的，让那群屌丝们等去吧，因为方圆960万平方公里就此一家，别无分号。

若你不是，哪天觉得自己有点生意有点扛不住或是那点生殖器破事被某个黑心，吃不到葡萄的院长小弟揭发了，扛不住随之而来的社会舆论压力，不能跟院长们OOXX了，只准对他们笑个，这个时候你得通知那些女服务员，说不准OOXX了，只能看了。若是你只有一家店，还好，自己喊一声，重新打印流程规章表，若是全国连锁的话...... 一桌的杯具摆在你茶几上。

4.正义化身的出现

好了，扯了这么多，终于要该AOP兄弟出场了，再不出估计戏都散场了。

针对以上的种种问题，我们该怎么处理这些我们店主要生意之外的杂事呢(OOXX),有什么更好的方式来随时应对种种变化。这个就是我们AOP兄弟想干的事情，从主业中剥离出这些杂事，进行单独处理的设计。主业务只关注于自己的领域，对于特殊领域的处理(OOXX),通过侧面来封装维护，这样使得散落在不同口味美女的特殊操作可以很好的管理起来。来段专业点的说明吧：

从主关注点中分离出横切关注点是面向侧面的程序设计的核心概念。分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特定领域问题代码的调用，业务逻辑同特定领域问题的关系通过侧面来封装、维护，这样原本分散在在整个应用程序中的变动就可以很好的管理起来。

好了，AOP的就是个这么简单的东西，别去想那些繁杂的spring配置和概念术语。它只是一种设计范型。

绕了这么久，让我们来打倒那些纸老虎吧。

我开饭店，屌丝、院长来吃饭，美女们招待顾客 ，这个是我们的主业。  ========  目标对象（Target Object） 就是店主我，我开了两个店，戏院和饭店

哦，北大院长来饭店吃饭了                                                            ========  切入点（Pointcut） 他们来我戏院看戏的话，不管，直管饭店的事

院长开始吃饭，喝酒了。                                                               ========  连接点（Joinpoint） ，就是我们的一些行为，院长如果来围观的话，无视之，哥是开饭店的。

院长想跟美女们OOXX了                                                               ========  通知（Advice）院长来了，也吃了饭了，那接下来干什么呢？通知就是决定干什么:OOXX或是洗脚

院长除了想OOXX之外，还想洗脚，那么怎么办呢？                           ========  切面（Aspect） ，规定院长来了可以干什么，就是决定可以有多少个通知：OOXX||洗脚 或是 OOXX &&　洗脚

----------------------------------------------------------------------------------------------------

院长想吃饭后洗脚                                                                ======== 后通知（After advice） 

院长想吃饭前洗脚                                                                ======== 前置通知（Before advice）

院长想根据吃饭后的心情决定是OOXX还是洗脚                         ======== 返回后通知（After return advice）

院长吃饭吃出脑中风了                                                          ======== 抛出异常后通知（After throwing advice）这个时候有个通知跳出来：打120，送医院！

院长想饭前洗脚，饭后OOXX                                                 ======== 环绕通知（Around advice）

作为老板的我，应该怎么更好的切入这些洗脚啊，OOXX服务呢    ======== AOP代理（AOP Proxy）怎么在干好招待顾客这件事上切入 洗脚||OOXX

若是上面的这些你还是看不明白的话，那么我们就具象到spring上，看看到底是件上面事吧。spring中Aspect叫Advisor。Joinpoint叫Weaving。很操蛋，也很让人无语的术语啊

切面：
package com.zhaming.aop.advice;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

/**
 * 后置通知
 * @author inter12
 *
 */
public class AfterAdvice implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("拦截了:" + method.getName() + "方法");
        System.out.println("洗脚");
    }

}


package com.zhaming.aop.advice;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 前置通知
 * 
 * @author inter12
 */
public class BeforeAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {

        System.out.println("拦截了:" + method.getName() + "方法");
        System.out.println("OOXX");
    }

}


package com.zhaming.aop.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * 环绕通知
 * 
 * @author inter12
 */
public class CompareAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object result = null;
        String userName = invocation.getArguments()[0].toString();
        if (null != userName && userName.equals("yuanzhang")) {
            System.out.println("院长通过---------------");
            result = invocation.proceed();
        } else {
            System.out.println("屌丝拒绝---------------");
        }
        return result;
    }

}

目标对象：
package com.zhaming.aop.restaurant;

public interface RestaurantService {

    public void zhaodaiguke(String userName);

    public void weiguan(String userName);
}

package com.zhaming.aop.restaurant;

/**
 * 目标对象
 * 
 * @author inter12
 */
public class RestaurantServiceImpl implements RestaurantService {

    @Override
    public void zhaodaiguke(String userName) {
        System.out.println("--------- 姑娘们在招待顾客:" + userName);
    }

    @Override
    public void weiguan(String userName) {
        System.out.println(userName + ":在围观");

    }

}

客户端：
package com.zhaming.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.zhaming.aop.restaurant.RestaurantService;

public class Main {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new FileSystemXmlApplicationContext(
                                                                                    "//home/inter12/workspace/Light/src/main/java/appcontext-aop.xml");

        RestaurantService bean = (RestaurantService) applicationContext.getBean("restaurantService");
        bean.zhaodaiguke("yuanzhang");
        bean.zhaodaiguke("diaosi");
    }
}

配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<!-- 通知 -->
	<bean id="beforeAdvice" class="com.zhaming.aop.advice.BeforeAdvice"></bean>
	<bean id="afterAdvice" class="com.zhaming.aop.advice.AfterAdvice"></bean>
	<bean id="compareAdvice" class="com.zhaming.aop.advice.CompareAdvice"></bean>

	<!-- 目标对象 -->
	<bean id="restaurantServiceTarget" class="com.zhaming.aop.restaurant.RestaurantServiceImpl"></bean>

	<bean id="restaurantService" class="org.springframework.aop.framework.ProxyFactoryBean">

		<!-- 拦截那些接口 : 切入点 只关心饭店的事-->
		<property name="proxyInterfaces">
			<value>com.zhaming.aop.restaurant.RestaurantService</value>
		</property>

		<!-- 对这些方式做那些拦截:切面 -->
		<property name="interceptorNames">
			<list>
				<!-- 
				<value>beforeAdvice</value>
				 
				<value>afterAdvice</value>
				-->
				<value>compareAdvice</value>
			</list>
		</property>

		<property name="target">
			<ref bean="restaurantServiceTarget" />
		</property>
	</bean>

</beans>

5.AOP能干什么？

现在回头看看最初问的五个问题，那些杂事，是不是可以对应到软件中的几个概念：日志记录，性能统计，安全控制，事务处理，异常处理，更衍生的提还有缓存，持久化，同步等

• —软件人才免语言低担保 赴美带薪读研！—

redis学习笔记3--sortSet

终于到最后一个数据结构了，加油！！

整体结构图：

http://dl.iteye.com/upload/picture/pic/115995/0ee3789f-33e1-35ca-ac65-cbd6b4e4e147.jpg

1.ZADD

语法： ZADD key score value 

释义：添加执行分数的value， score必须是double类型的数值

实践：

redis 127.0.0.1:6379> zadd z1 1 a 

(integer) 1

redis 127.0.0.1:6379> zadd z1 2 b 

(integer) 1

redis 127.0.0.1:6379> zadd z1 20 bb 

(integer) 1

redis 127.0.0.1:6379> zadd z1 10 ff  

(integer) 1

redis 127.0.0.1:6379> zrange z1 0 -1 

1) "a"

2) "b"

3) "ff"

4) "bb"

2.ZREM

语法:ZREM key value 

释义：删除指定value的值

实践：

redis 127.0.0.1:6379> ZREM z1 b            // 删除，指定value

(integer) 1

redis 127.0.0.1:6379> zrange z1 0 -1         

1) "a"

2) "ff"

3) "bb"

3.ZCARD

语法：ZCARD key 

释义：获取集合总数

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 

1) "a"

2) "ff"

3) "bb"

redis 127.0.0.1:6379> zcard z1 

(integer) 3

4.ZCOUNT

语法:zcount key min max

释义：计算在指定范围内的元素数目

(1 6  ==== 1 < x <= 6        // 括号代表开区间

1 6   ==== 1 <= x <= 6

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "1"

3) "ff"

4) "10"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zcount z1 5 10      // 闭区间，能取得10

(integer) 1

redis 127.0.0.1:6379> zcount z1 5 (10     //开区间，无法得到10

(integer) 0

5.ZSCORE

语法：ZSCORE key value

释义：获取指定key的分数

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "1"

3) "ff"

4) "10"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zscore z1 a             // 获取a的分数

"1"

6.ZINCRBY

语法：ZINCRBY key score value 

释义：对于指定的value进行加法操作

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "1"

3) "ff"

4) "10"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zincrby z1 10 a            // 对于a+10

"11"

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "ff"

2) "10"

3) "a"

4) "11"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zincrby z1 -3 a          // 对于a-3

"8"

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "8"

3) "ff"

4) "10"

5) "bb"

6) "20"

7.ZRANGE|ZREVRANGE

语法：ZRANGE|ZREVRANGE key 

释义：显示所有列表

redis 127.0.0.1:6379> zrange z1 0 -1 

1) "a"

2) "ff"

3) "bb"

redis 127.0.0.1:6379> zrevrange z1 0 -1 

1) "bb"

2) "ff"

3) "a"

8.ZRANGEBYSCORE|ZREVRANGEBYSCORE

语法：ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

释义：获取指定范围内的数值

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "8"

3) "ff"

4) "10"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zrangebyscore z1 -inf +inf   // 在不清楚最大最小范围的时间，可以采用这个 -inf +inf 

1) "a"

2) "ff"

3) "bb"

redis 127.0.0.1:6379> zrangebyscore z1 8 10       // 闭区间

1) "a"

2) "ff"

redis 127.0.0.1:6379> zrangebyscore z1 (8 10      // 开区间

1) "ff"

9.ZRANK|ZREVRANK

语法：zrank|zremrank  key member

释义：获取指定值在集合中的排名，以０代表第一位　。（顺序或是逆序）

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "a"

2) "8"

3) "ff"

4) "10"

5) "bb"

6) "20"

redis 127.0.0.1:6379> zrank z1 a 

(integer) 0

redis 127.0.0.1:6379> zrank z1 ff　　　　　//顺序位置

(integer) 1 

redis 127.0.0.1:6379> zrevrank z1 a        //逆序位置

(integer) 2

10.ZREMRANGEBYRANK

语法 :ZREMRANGEBYRANK key min max 

释义：删除指定下标的数据

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 

1) "a"

2) "ff"

3) "bb"

redis 127.0.0.1:6379> zremrangebyrank z1 0 1 

(integer) 2

redis 127.0.0.1:6379> zrange z1 0 -1 

1) "bb"

11.ZREMRANGEBYSCORE

语法 :ZREMRANGEBYSCORE key min max

释义：根据指定分数删除数据

实践：

redis 127.0.0.1:6379> zrange z1 0 -1 withscores 

1) "bb"

2) "20"

redis 127.0.0.1:6379> ZREMRANGEBYSCORE z1 -inf +inf    // 删除所有的数据 等同于  del z1

(integer) 1

redis 127.0.0.1:6379> zrange z1 0 -1 

(empty list or set)

12.ZINTERSTORE

语法：ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

释义：

  计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。

  默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.

实践：

redis 127.0.0.1:6379> zrange s1 0 -1 

1) "a"

2) "b"

3) "c"

redis 127.0.0.1:6379> zrange s2 0 -1 

1) "a"

2) "c"

3) "d"

redis 127.0.0.1:6379> zinterstore s3 2 s1 s2 

(integer) 2

redis 127.0.0.1:6379> zrange s3 0 -1 

1) "a"

2) "c"

redis 127.0.0.1:6379> 

13.ZUNIONSTORE

语法：ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

释义：计算给定的一个或多个有序集的并集，其中给定 key 的数量必须以 numkeys 参数指定，并将该并集(结果集)储存到 destination 。

默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。

WEIGHTS

 使用 WEIGHTS 选项，你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。

 如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1 。

AGGREGATE

 使用 AGGREGATE 选项，你可以指定并集的结果集的聚合方式。

 默认使用的参数 SUM ，可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值；使用参数 MIN ，可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值；而参数 MAX 则是将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值。

实践：

redis 127.0.0.1:6379> zunionstore s3 2 s1 s2 

(integer) 4

redis 127.0.0.1:6379> zrange s3 0 -1 

1) "b"

2) "a"

3) "c"

4) "d"

redis 127.0.0.1:6379> 

• —软件人才免语言低担保 赴美带薪读研！—

redis学习笔记3--set

list:有序且，允许重复数据的链表 存在POP PUSH的概念

set: 无需序，不能重复的集合 主要是ADD 

sortSet：有序，不能重复的集合 

整体结构图：

http://dl.iteye.com/upload/picture/pic/115943/f6e6971a-0216-3fe3-b89c-4ec5b53b762a.jpg

1.SADD 新增元素

语法： sadd key value 

实践：

redis 127.0.0.1:6379> sadd s1 1

(integer) 1

redis 127.0.0.1:6379> sadd s1 2 

(integer) 1

redis 127.0.0.1:6379> sadd s2 3 

(integer) 1

redis 127.0.0.1:6379> sadd s1 1      // 重复数据不会被添加

(integer) 0

redis 127.0.0.1:6379>

2.SREM 删除元素

语法：srem key value 

实践：

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

redis 127.0.0.1:6379> srem s1 1       // 删除s1中的1元素

(integer) 1

redis 127.0.0.1:6379> smembers s1 

1) "2"

redis 127.0.0.1:6379> 

3.SMEMBERS 列出所有信息 类似list的 lrange

语法：smembers key 

实践：

redis 127.0.0.1:6379> smembers s1 

1) "2"

redis 127.0.0.1:6379> 

4.SISMEMBER 判断是否存在该元素

语法：sismember key value 

1:存在该元素

0:不存在

实践：

redis 127.0.0.1:6379> sismember s1 1   存在的元素返回1

(integer) 1

redis 127.0.0.1:6379> sismember s1 3   不存在的元素返回0

(integer) 0

redis 127.0.0.1:6379>

5.SCARD 计算集合中元素总数 size

语法：scard key 

实践：

redis 127.0.0.1:6379> scard s1     // 返回集合中元素个数

(integer) 2

redis 127.0.0.1:6379> 

6.SMOVE 将集合中一个元素转移到另一个集合中

语法: smove  source destination value 

实践：

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

redis 127.0.0.1:6379> smembers s2

(empty list or set)

redis 127.0.0.1:6379> smove s1 s2 1    // 将S1中的1移动到了S2中

(integer) 1

redis 127.0.0.1:6379> smembers s1 

1) "2"

redis 127.0.0.1:6379> smembers s2

1) "1"

redis 127.0.0.1:6379>

7.SPOP 随机弹出一个元素

语法： spop key 

实践：

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

3) "3"

4) "4"

redis 127.0.0.1:6379> spop s1           // 随机弹出一个元素

"3"

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

3) "4"

redis 127.0.0.1:6379> 

8.SRANDMEMBER 随机获取一个元素，但是不弹出集合,这个是跟SPOP唯一的区别

语法: SRANDMEMBER

实践：

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

3) "4"

redis 127.0.0.1:6379> SRANDMEMBER s1   //  随机取得一个数据，但是元素不会丢失

"4"

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

3) "4"

redis 127.0.0.1:6379>

9.SINTER 取两个集合的交集

语法：SINTER key1 key2 

实践：

redis 127.0.0.1:6379> smembers s2 

1) "1"

2) "10"

redis 127.0.0.1:6379> smembers s1 

1) "1"

2) "2"

3) "4"

redis 127.0.0.1:6379> sinter s1 s2    // 两个集合共同的元素是 1 

1) "1"

redis 127.0.0.1:6379>

10.SINTERSTORE 取两个集合的交集并保存到另一个集合中 

语法：SINTERSTORE destination key1 key2 

实践：

redis 127.0.0.1:6379> smembers s1

1) "1"

2) "2"

3) "3"

redis 127.0.0.1:6379> smembers s2

1) "1"

2) "10"

redis 127.0.0.1:6379> smembers s3                 //这个时候S3是空的

(empty list or set)

redis 127.0.0.1:6379> sinterstore s3  s1 s2       //取两个的交集并保存到s3 中

(integer) 1

redis 127.0.0.1:6379> smembers s3

1) "1"

redis 127.0.0.1:6379>

11.SUNION  取两个集合的并集 

语法：SUNION key1 key2 

实践：

redis 127.0.0.1:6379> smembers s1

1) "1"

2) "2"

3) "3"

redis 127.0.0.1:6379> smembers s2

1) "1"

2) "10"

redis 127.0.0.1:6379> sunion s1 s2              // 取得两个集合的并集

1) "1"

2) "2"

3) "3"

4) "10"

redis 127.0.0.1:6379> 

12.SUNIONSTORE 取两个集合的并集并保存到另一个集合中 

语法: SUNIONSTORE destination key1 key2  

实践：

redis 127.0.0.1:6379> smembers s1

1) "1"

2) "2"

3) "3"

redis 127.0.0.1:6379> smembers s2

1) "1"

2) "10"

redis 127.0.0.1:6379> sunionstore  s4 s1 s2 

(integer) 4

redis 127.0.0.1:6379> smembers s4

1) "1"

2) "2"

3) "3"

4) "10"

redis 127.0.0.1:6379> 

13.SDIFF 取两个集合的差集

语法：SDIFF key1 key2

实践：

redis 127.0.0.1:6379> smembers s1

1) "1"

2) "2"

3) "3"

redis 127.0.0.1:6379> smembers s2

1) "1"

2) "10"

redis 127.0.0.1:6379> sdiff s1 s2    // 获取的是两个之间的差集

1) "2"

2) "3"

redis 127.0.0.1:6379> 

14.SDIFFSTORE 取两个集合的差集 并保存到第三个集合中

语法:SDIFFSTORE key1 key2 diffSet

实践：

redis 127.0.0.1:6379> smembers s1

1) "1"

2) "2"

3) "3"

redis 127.0.0.1:6379> smembers s2

1) "1"

2) "10"

redis 127.0.0.1:6379> sdiffstore s5  s1 s2    // 将差集的数据保存到s5中 

(integer) 2

redis 127.0.0.1:6379> smembers s5

1) "2"

2) "3"

• —软件人才免语言低担保 赴美带薪读研！—

图画的太大了，只能放地址：

http://dl.iteye.com/upload/picture/pic/115935/8e96f42d-3a7b-3cea-85ae-997496aa9521.jpg

LIST列表的操作，可想而知，对于列表我们需要的具备的功能列表

加入列表：

  从头部加入   LPUSH 

  从底部加入   RPUSH

弹出列表

  从头部弹出   LPOP

  从底部弹出   RPOP

截取子列表     LRANGE

计算列表的长度 LLEN

实践：

redis 127.0.0.1:6379> rpush l2 1     // 从底部添加一个元素

(integer) 1

redis 127.0.0.1:6379> rpush l2 2 

(integer) 2

redis 127.0.0.1:6379> lrange l2 0 -1 // 展示所有的元素  -1 代表所有

1) "1"

2) "2"

redis 127.0.0.1:6379> lpush l2 3 

(integer) 3

redis 127.0.0.1:6379> lrange l2 0 -1 

1) "3"

2) "1"

3) "2"

redis 127.0.0.1:6379> lpop l2       // 从头部弹出一个元素

"3"

redis 127.0.0.1:6379> rpop l2       // 从尾部弹出一个元素

"2"

redis 127.0.0.1:6379> llen l2       // 计算队列的长度

(integer) 1

扩展

1.1 LPUSHX  当且队列存在的情况下 在头部插入数据 

LPUSHX key value

实践：

redis 127.0.0.1:6379> LLEN empty1            

(integer) 0

redis 127.0.0.1:6379> lpushx empty1 hh    // 将数据推入一个空的队列，结果失败

(integer) 0

redis 127.0.0.1:6379> lpush l3 hh 

(integer) 1

redis 127.0.0.1:6379> lpushx l3 hh2      // 将数据推入一个存在的队列头部，成功

(integer) 2

redis 127.0.0.1:6379> lrange l3 0 -1 

1) "hh2"

2) "hh"

1.2 RPUSHX 当且队列存在的情况下 在尾部插入数据  基本同LPUSHX

redis 127.0.0.1:6379> rpushx empty1 hh3    // 尝试将数据推入不存在队列的尾部，失败。

(integer) 0

redis 127.0.0.1:6379> rpushx l3 hh3        // 将数据推入存在队列的尾巴，成功。

(integer) 3

redis 127.0.0.1:6379> lrange l3 0 -1

1) "hh2"

2) "hh"

3) "hh3"

1.3 BLPOP 对于LPOP的扩展 ，阻塞式的获取数据

BLPOP key [key ...] timeout

它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。

当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。

假设现在有三个队列 job 为空 ， command  request 不为空 。那么就开始轮训所有的key ，若是空，则跳过 。执行顺序为 job ==> command ==> request

实践：

redis 127.0.0.1:6379> del job 

(integer) 0

redis 127.0.0.1:6379> lpush command hh 

(integer) 1

redis 127.0.0.1:6379> lpush request kk 

(integer) 1

redis 127.0.0.1:6379> blpop job command kk 

(error) ERR timeout is not an integer or out of range

redis 127.0.0.1:6379> blpop job command kk  100 

1) "command"

2) "hh"

redis 127.0.0.1:6379>

查看其是如何阻塞的

在第一个图片中，上面那个终端一直阻塞着。

在第二个终端中输入数据后，上面终端取得数据并返回。

1.4 BRPOP 对于rpop的扩展，原理基本同BLPOP

2.LREM

语法：LREM key count value

释义：根据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值可以是以下几种：

  count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。

  count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。

  count = 0 : 移除表中所有与 value 相等的值。

实践：

redis 127.0.0.1:6379> lpush l1 hello 

(integer) 1

redis 127.0.0.1:6379> lpush l1 world 

(integer) 2

redis 127.0.0.1:6379> lpush l1 hello 

(integer) 3

redis 127.0.0.1:6379> lpush l1 world 

(integer) 4

redis 127.0.0.1:6379> lpush l1 hello 

(integer) 5

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "hello"

2) "world"

3) "hello"

4) "world"

5) "hello"

redis 127.0.0.1:6379>                       // 数据准备完成

redis 127.0.0.1:6379> lrem l1 2 hello      // 从头部开始扫描，移除了两个hello 

(integer) 2

redis 127.0.0.1:6379> lrem l1 -1 hello     // 从尾部开始扫描，移除了一个hello

(integer) 1

redis 127.0.0.1:6379> lrange l1 0 -1       // 现在只剩下 world了

1) "world"

2) "world"

redis 127.0.0.1:6379> lrem l1 0 world     // 移除队中所有的world 

(integer) 2

redis 127.0.0.1:6379> lrange l1 0 -1      // 已经被清空了。

(empty list or set)

redis 127.0.0.1:6379> 

3.LSET

语法：LSET key index value

释义：将列表 key 下标为 index 的元素的值设置为 value 。

实践：

redis 127.0.0.1:6379> lpush l1 hello 

(integer) 1

redis 127.0.0.1:6379> lpush l1 world 

(integer) 2

redis 127.0.0.1:6379> lset l1 1  ---      // 下标为1的数据被替换成 --- 了

OK

redis 127.0.0.1:6379> lrange l1 0 -1

1) "world"

2) "---"

redis 127.0.0.1:6379> lset l1 3 hh       // 超出下标进行设置的话，报错

(error) ERR index out of range

redis 127.0.0.1:6379> exist l2 

(error) ERR unknown command 'exist'

redis 127.0.0.1:6379> exists l2          // 对不存在的队列进行设置的话，报错

(integer) 0

redis 127.0.0.1:6379> lset l2 0 hh 

(error) ERR no such key

redis 127.0.0.1:6379> 

4 LTRIM

语法：LTRIM key start stop

释义：对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

 超出范围的下标值不会引起错误。

 如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，或者 start > stop ， LTRIM 返回一个空列表(因为 LTRIM 已经将整个列表清空)。

 如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 

实践：

redis 127.0.0.1:6379> lrange l1 0 -1    // 新建一个队列 

1) "h"

2) "e"

3) "l"

4) "l"

5) "o"

redis 127.0.0.1:6379> ltrim l1 0 3     // 只截取前四个 

OK

redis 127.0.0.1:6379> lrange l1 0 -1

1) "h"

2) "e"

3) "l"

4) "l"

redis 127.0.0.1:6379> ltrim l1 0 10    // stop下标大于队列长度 则 stop=队列长度

OK

redis 127.0.0.1:6379> lrange l1 0 -1

1) "h"

2) "e"

3) "l"

4) "l"

redis 127.0.0.1:6379> lset l1 10 20  // start stop 都大于 队列长度 且 start <　stop 清空队列

(empty list or set)

redis 127.0.0.1:6379> ltrim l1 3 1     // start  <　stop 清空队列

OK

redis 127.0.0.1:6379> lrange l1 10 20 

(empty list or set)

5.LINDEX

语法：LINDEX key index

释义：返回列表 key 中，下标为 index 的元素。

 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。

 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

实践：

redis 127.0.0.1:6379> lpush l1 1 

(integer) 1

redis 127.0.0.1:6379> lpush l1 2

(integer) 2

redis 127.0.0.1:6379> lpush l1 3

(integer) 3

redis 127.0.0.1:6379> lindex l1 0            // 取下标为0的数据

"3"

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "3"

2) "2"

3) "1"

redis 127.0.0.1:6379> lindex l1 -1          // 取最后一个数据

"1"

redis 127.0.0.1:6379> 

6. LINSERT  类似于LSET,一个是根据下标来插入，一个是根据pivot来插入数据。

语法：LINSERT key BEFORE|AFTER pivot value

释义：将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。

  当 pivot 不存在于列表 key 时，不执行任何操作。

  当 key 不存在时， key 被视为空列表，不执行任何操作。

  如果 key 不是列表类型，返回一个错误。

实践：

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "redis"

2) "hello"

3) "world"

4) "hello"

redis 127.0.0.1:6379> linsert l1 after hello after-insert          // 在第一个找到的hello后面插入了一个数据 

(integer) 5

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "redis"

2) "hello"

3) "after-insert"

4) "world"

5) "hello"

redis 127.0.0.1:6379> linsert l1 before hello before-insert       // 在第一个找到的hello前面插入了一个数据 

(integer) 6

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "redis"

2) "before-insert"

3) "hello"

4) "after-insert"

5) "world"

6) "hello"

redis 127.0.0.1:6379> linsert l1 before hoho before-insert       // 对于 pivot 不存在的列表，插入失败

(integer) -1

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "redis"

2) "before-insert"

3) "hello"

4) "after-insert"

5) "world"

6) "hello"

redis 127.0.0.1:6379> linsert l2 before hoho before-insert       // 插入一个空列表，直接报错

(integer) 0

7. RPOPLPUSH 

语法：RPOPLPUSH source destination

释义：

命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：

 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。

 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。

举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。

 如果 source 不存在，值 nil 被返回，并且不执行其他动作。

 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

实践：

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "c"

2) "b"

3) "a"

redis 127.0.0.1:6379> lrange l2 0 -1

1) "3"

2) "2"

3) "1"

redis 127.0.0.1:6379> rpoplpush l1 l2     //将l1尾部的数据弹出进入l2的头部,并将这个弹出的数据返回

"a"

redis 127.0.0.1:6379> lrange l1 0 -1 

1) "c"

2) "b"

redis 127.0.0.1:6379> lrange l2 0 -1 

1) "a"

2) "3"

3) "2"

4) "1"

redis 127.0.0.1:6379>

8. BRPOPLPUSH 

语法：BRPOPLPUSH source destination timeout

释义：BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。

   当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。

   超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。

实践：

我们设置等超时时间为1000 

在另一个客户端添加数据后，就转移了数据

• —软件人才免语言低担保 赴美带薪读研！—

NOSQL的学习笔记：

1.最基本的命令

相信所有的NOSQL都会提供了命令：GET SET DEL 

--------------------------------------

redis 127.0.0.1:6379> set ee 10 

OK

redis 127.0.0.1:6379> get ee 

"10"

redis 127.0.0.1:6379> del ee              // 返回值 1:代表正确 0：代表错误

(integer) 1

redis 127.0.0.1:6379> get ee  

(nil)

redis 127.0.0.1:6379>

--------------------------------------

del key1 key2 key3  //可删除多个key

扩展：

1.1 SETNX:设置一个值，如果不存在的话,已经存在则不新增.对于SET的扩展。

--------------------------------------

redis 127.0.0.1:6379> set ee 10 

OK

redis 127.0.0.1:6379> setnx ee 20 

(integer) 0

redis 127.0.0.1:6379> get ee             // 因为之前存在ee  所以ee的值并没有发生变化。

"10"

redis 127.0.0.1:6379> setnx aa 20        //  aa 之前不存在，所以设置成功！

(integer) 1

redis 127.0.0.1:6379> get aa 

"20"

redis 127.0.0.1:6379> 

--------------------------------------

1.2 SETEX 设置过期时间，对于SET的扩展。若是已经存在，会覆盖原来的值。

语法:

SETEX key seconds value

要求版本：>= 2.0.0

实践：

--------------------------------------

redis 127.0.0.1:6379> setex ee 10 20 

OK

redis 127.0.0.1:6379> get ee 

"20"

redis 127.0.0.1:6379> ttl ee 

(integer) 4

redis 127.0.0.1:6379> ttl ee 

(integer) 2

redis 127.0.0.1:6379> ttl ee 

(integer) -1

redis 127.0.0.1:6379> get ee 

(nil)

redis 127.0.0.1:6379> 

--------------------------------------

限制：

等同于一下语句，不过是一个原子性的操作，很适合做缓存使用。

SET key value

EXPIRE key seconds  # 设置生存时间

1.3 PSETEX  对于 SETEX的再次扩展，唯一的区别是以毫秒为单位，不是以秒为单位

语法：

PSETEX key milliseconds value

要求版本：>= 2.6.0

实践：

--------------------------------------

redis 127.0.0.1:6379> setex ee 10 20 

OK

redis 127.0.0.1:6379> get ee 

"20"

redis 127.0.0.1:6379> ttl ee 

(integer) 4

redis 127.0.0.1:6379> ttl ee 

(integer) 2

redis 127.0.0.1:6379> ttl ee 

(integer) -1

redis 127.0.0.1:6379> get ee 

(nil)

redis 127.0.0.1:6379> 

--------------------------------------

1.4 MGET , MSET

获取多个值或是设置多个值。

MSET ：替换旧值，原子操作。

实践：

--------------------------------------

redis 127.0.0.1:6379> mset key1 haha key2 hehe 

OK

redis 127.0.0.1:6379> mget key1 key2 

1) "haha"

2) "hehe"

redis 127.0.0.1:6379> 

--------------------------------------

1.5 MSETNX ：设置多个key value,仅当key存在时  

MSETNX key value [key value ...] 

既然有setnx 就会有 这个命令

实践：

--------------------------------------

redis 127.0.0.1:6379> msetnx key1 hehe key3 hoho              //因为这是一个原子的操作，所以key1已经存在，所以整体失败了！

(integer) 0

redis 127.0.0.1:6379> mget key1 key2 key3                     // 找不到所要的key3

1) "haha"

2) "hehe"

3) (nil)

redis 127.0.0.1:6379> 

--------------------------------------

1.6 GETSET

GETSET key value 设置一个key的value，并获取设置前的值 。相当于重置功能。

实践：

--------------------------------------

redis 127.0.0.1:6379> incrby count 10 

(integer) 10

redis 127.0.0.1:6379> getset count "5"    // 这个时候返回的是10，不是5

"10"

redis 127.0.0.1:6379> get count 

"5"

redis 127.0.0.1:6379> 

--------------------------------------

有时我们需要获取计数器的值，并且自动将其重置为0

1.7 GETRANGE 获取存储在一个关键的一个子字符串

实践：

--------------------------------------

redis 127.0.0.1:6379> set longworld "hello world!"

OK

redis 127.0.0.1:6379> getrange  longworld 0 5 

"hello "

redis 127.0.0.1:6379> getrange longworld -6 -1 

"world!"

redis 127.0.0.1:6379> 

redis 127.0.0.1:6379> getrange longworld 5 100     // 超出范围的数据只取最后位

" world!"

--------------------------------------

1.8 SETRANGE 类似于GETRANGE 覆盖在指定的偏移量开始的关键字符串的一部分

实践：

--------------------------------------

redis 127.0.0.1:6379> setrange longworld 6 "redis"

(integer) 12

redis 127.0.0.1:6379> get longworld 

"hello redis!"

redis 127.0.0.1:6379> 

--------------------------------------

1.9 STRLEN  计算长度

语法：

STRLEN key 

实践：

--------------------------------------

redis 127.0.0.1:6379> strlen longworld 

(integer) 12

--------------------------------------

1.10 append 追加数据 ，setrange是截取字符

语法：

append key str

实践：

--------------------------------------

redis 127.0.0.1:6379> append longworld "!!!"

(integer) 15

redis 127.0.0.1:6379> get longworld 

"hello redis!!!!"

--------------------------------------

3.INCR :对于一个数值做递增，步伐是1。

限制：

只允许对于数值类型做操作，若是字符串类型则报错。

是否线程安全：是的，是一个原子操作，不用担心多线程并发修改同一个值得问题。

即不会出现一下情况：

--------------------------------------

    Client A reads count as 10.

    Client B reads count as 10.

    Client A increments 10 and sets count to 11.

    Client B increments 10 and sets count to 11.

--------------------------------------

若是希望递增的频率不是1呢，那么使用INCRBY 

--------------------------------------

redis 127.0.0.1:6379> set ee 10 

OK

redis 127.0.0.1:6379> incrby ee 2     // 第三个参数是步频

(integer) 12

redis 127.0.0.1:6379> get ee 

"12"

--------------------------------------

扩展：

INCR &&INCRBY 对应的命令是 DECR ，DECRBY

4.如何设置一个key的过期时间呢？

简单，通过 EXPIRE来设置，通过TTL命令查看。

--------------------------------------

redis 127.0.0.1:6379> set ee 10

OK

redis 127.0.0.1:6379> expire ee 10          // 设置过期时间为10秒

(integer) 1

redis 127.0.0.1:6379> ttl ee

(integer) 8

redis 127.0.0.1:6379> ttl ee

(integer) 3

redis 127.0.0.1:6379> ttl ee                // 已经过期了。

(integer) -1

redis 127.0.0.1:6379> get ee                // 已经取不到值了  

(nil)

redis 127.0.0.1:6379>                  

--------------------------------------

若是不设置expire ，只是set 一个值后，再通过ttl 查看 返回结果是 -1 ，代表永远不过期。

--------------------------------------

redis 127.0.0.1:6379> set ee 10 

OK

redis 127.0.0.1:6379> ttl ee 

(integer) -1

redis 127.0.0.1:6379> get ee 

"10"

--------------------------------------

一个整体结构图：

图太大 还是自己贴地址吧：

http://dl.iteye.com/upload/picture/pic/115893/840bfd7b-765e-3884-8253-0c7b3ec9db4c.jpg

• —软件人才免语言低担保 赴美带薪读研！—

wget http://download.redis.io/redis-stable.tar.gz

tar xvzf redis-stable.tar.gz

cd redis-stable

make

如此就已经安装完成了，当然也可以采用make test来看看安装是否正确。

基本常用命令：

redis-server ：运行一个redisserver

redis-cli :redis命令行版本的客户端，同本地或是远程redis服务进行交互

redis-benchmark : 检查redis服务性能的命令

redis-check-aof and redis-check-dump are useful in the rare event of corrupted data files.

若是在make的时候没有将redis-server，redis-cli拷贝到/usr/local/bin目录下，那么手工拷贝下。

sudo cp redis-server /usr/local/bin/

sudo cp redis-cli /usr/local/bin/

2.启动redis

inter12@inter12-VirtualBox:~$ redis-server

[2233] 27 Jun 09:23:04 # Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'

[2233] 27 Jun 09:23:04 * Server started, Redis version 2.4.15

[2233] 27 Jun 09:23:04 # WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.

[2233] 27 Jun 09:23:04 * DB loaded from disk: 0 seconds

[2233] 27 Jun 09:23:04 * The server is now ready to accept connections on port 6379

[2233] 27 Jun 09:23:04 - DB 0: 1 keys (0 volatile) in 4 slots HT.

[2233] 27 Jun 09:23:04 - 0 clients connected (0 slaves), 717624 bytes in use

不带任何参数的情况，采用的是默认的配置文件。这个只适用于开发环境，生成环境需要自己制定一个配置文件。具体命令是： redis-server /etc/redis.conf 

3.检查redis是否正常工作

inter12@inter12-VirtualBox:~$ redis-cli ping

PONG

返回PONG就代表是OK的。

4.redis的常用命令

redis 127.0.0.1:6379> set haha 'zhaoming'

OK

redis 127.0.0.1:6379> get haha

"zhaoming"

所有完整的命令可见:

http://redis.readthedocs.org/en/latest/

还有所有可用客户端：

http://redis.io/clients

5.redis的持久化

因为是内存型的NOSQL，有两种方式。1.使用save命令，会将数据刷新到文件中。2.采用redis-cli shutdown 会将内存中数据刷新到文件中

更详细的可见：

http://redis.io/topics/persistence

6.正确的部署redis

1.采用界面部署

2.在linux上，采用一个初始化脚本部署(更推荐这种)

如何采用第二种进行部署呢。

s1)建立配置文件及数据文件目录

mkdir /etc/redis 

mkdir /var/redis 

s2)将初始化脚本放到/etc/init.d目录下,并建议根据端口号进行文件命名

cp /home/inter12/install/soft/redis/redis-stable/utils/redis_init_script /etc/init.d/redis_6379

编辑 /etc/init.d/redis_6379 ，确保端口是你想设置的。

s3)拷贝redis.conf到 /etc/redis目录下

sudo cp /home/inter12/install/soft/redis/redis-stable/redis.conf /etc/redis/6379.conf

s4)在/var/redis目录下建立一个redis实例对应的目录

mkdir /var/redis/6379 

s5)修改配置文件

设置daemonize 为yes(默认是no)

设置pidfile 到 /var/run/redis_6379.pid(可以改变端口)

设置日志级别loglevel

设置logfile 到 /var/log/redis_6379.log

设置 dir 到 /var/redis/6379 (这个是最重要的)

s6)最后添加初始化配置文件到所有运行级别下

sudo update-rc.d redis_6379 defaults   // 告诉系统启动时候，自动执行redis_6379这个脚本。

如此就搞定了所有配置修改工作，就可以如此启动了：

/etc/init.d/redis_6379 start

通过以下方式确保运行成功：

通过 redis-cli 尝试连接

运行 redis-cli ，然后 save 检查是否生成一个数据文件到 /var/redis/6379/目录下。 (应该能找到一个 dump.rdb文件).

检查是否在 /var/redis/6379/目录下生成文件

重启后，再次检查以上步骤。

• —软件人才免语言低担保 赴美带薪读研！—

分为 server  + client 

server的安装：

1.添加 deb http://www.rabbitmq.com/debian/ testing main 到 /etc/apt/sources.list

2.apt-get update.

3.sudo apt-get install rabbitmq-server

这个步骤会自动启动 rabbitmq-server 服务。

常用命令：

rabbitmqctl -h 

rabbitmqctl status 

rabbitmqctl stop

rabbitmqctl start_app

客户端安装：

maven:

<dependency>

  <groupId>com.rabbitmq</groupId>

  <artifactId>amqp-client</artifactId>

  <version>2.8.4</version>

</dependency>

或是下载链接：

wget http://www.rabbitmq.com/releases/rabbitmq-java-client/v2.8.4/rabbitmq-java-client-bin-2.8.4.tar.gz

客户端编码---发送者：

package com.jieting.mq.rabbit.send;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class MessageSend {

    private static final String QUENE_NAME = "hello";

    public static void main(String[] args) throws IOException {

        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");

        Connection newConnection = connectionFactory.newConnection();
        Channel createChannel = newConnection.createChannel();

        createChannel.queueDeclare(QUENE_NAME, true, false, false, null);
        String message = "hello rabbitmq world!";
        createChannel.basicPublish("", QUENE_NAME, null, message.getBytes());

        System.out.println(" [x] Sent '" + message + "'");

        createChannel.close();
        newConnection.close();

    }
}

消费者代码：

package com.jieting.mq.rabbit.receive;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.ShutdownSignalException;

public class MessageReceive {

    private static final String QUENE_NAME = "hello";

    public static void main(String[] args) throws IOException, ShutdownSignalException, ConsumerCancelledException,
                                          InterruptedException {

        ConnectionFactory connectionFactory = new ConnectionFactory();
        Connection newConnection = connectionFactory.newConnection();
        Channel createChannel = newConnection.createChannel();

        createChannel.queueDeclare(QUENE_NAME, true, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        QueueingConsumer queueingConsumer = new QueueingConsumer(createChannel);
        createChannel.basicConsume(QUENE_NAME, true, queueingConsumer);
        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
        }
    }
}

以上资料都可从 一下地址找到：

http://www.rabbitmq.com/java-client.html

http://www.rabbitmq.com/getstarted.html

• —软件人才免语言低担保 赴美带薪读研！—