WINDOWS 下， Redis 单机事务测试

22343213

WIN 10： i5 4440， 8GB
测试REDIS的事务速度

REDIS的WATCH机制实现事务是一个乐观锁形式（应该是SPIN LOCK的一种）。适用于并发度不是很高的场景，可以节约CPU资源（轻量级锁）。但是当竞争激烈的情况下，失败概率会大大提升，大量失败后的重试会耗费CPU资源。

测试的逻辑
    1）读取计数器
    2）JAVA端自增
    3）设置回REDIS

此处不可用REDIS自带的incr函数，REDIS服务器端为单线程执行，所以服务器端只执行一个incr指令的情况下，其实可以看作原子操作, 服务器端直接执行1-2秒就可以了，当然取决于电脑。
计数器计算到10万为止。（线程增多，那么每个线程负载计算量就减少）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113

package one; import java.text.NumberFormat; import java.util.concurrent.CountDownLatch; import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; public class TransactionContentionTest extends ConnectionBuilder {     private static final int CONTENTION_LEVEL = 5;     private static final int TOTAL = 20000;     private static final NumberFormat nf = NumberFormat.getPercentInstance();     public static void main(String[] args) throws Exception {         nf.setMinimumFractionDigits(2);         buildPool();         CountDownLatch latch = new CountDownLatch(CONTENTION_LEVEL);         Thread[] threads = new Thread[CONTENTION_LEVEL];         ContentionClient[] clients = new ContentionClient[CONTENTION_LEVEL];         Jedis jedis = pool.getResource();         jedis.set("TestCounter", "0");         jedis.close();         for (int i = 0; i < CONTENTION_LEVEL; i++) {             ContentionClient client = new ContentionClient();             client.setTotal(TOTAL);             client.setCounterName("TestCounter");             client.setJedis(pool.getResource());             client.setLatch(latch);             clients = client;             threads = new Thread(client);         }         long start = System.currentTimeMillis();         for (int i = 0; i < CONTENTION_LEVEL; i++) {             threads.start();         }         latch.await();         long end = System.currentTimeMillis();         System.out.println("Elapse:" + (end - start) + " ms");         for (int i = 0; i < CONTENTION_LEVEL; i++) {             Double failRate = (double) clients.getFailCount() / TOTAL;             System.out.println(i + " Fail Rate:" + nf.format(failRate));             clients.getJedis().close();         }         close();     }     static class ContentionClient implements Runnable {         private Jedis jedis;         private String counterName;         private int total;         private long failCount = 0;         public CountDownLatch getLatch() {             return latch;         }         public void setLatch(CountDownLatch latch) {             this.latch = latch;         }         private CountDownLatch latch;         public Jedis getJedis() {             return jedis;         }         public void setJedis(Jedis jedis) {             this.jedis = jedis;         }         public String getCounterName() {             return counterName;         }         public void setCounterName(String counterName) {             this.counterName = counterName;         }         public int getTotal() {             return total;         }         public void setTotal(int total) {             this.total = total;         }         public long getFailCount() {             return failCount;         }         public void setFailCount(long failCount) {             this.failCount = failCount;         }         @Override         public void run() {             while (total > 0) {                 jedis.watch(counterName);                 Integer counter = Integer.parseInt(jedis.get(counterName));                 Transaction tx = jedis.multi();                 counter++;                 tx.set(counterName, counter.toString());                 if (tx.exec() == null) {                     jedis.unwatch();                     failCount++;                 } else {                     total--;                 }             }             latch.countDown();         }     } }

分别测试多组数据

线程数	1	2	4	8	16
重试率	0	67%	185%	435%	900%
耗时	21055ms	19312	21136	34231	65964

用乐观锁机制并发度稍微高一点的情况，资源耗费非常严重。

毕竟用的是WINDOWS和家用机，测试的数据，没有参考价值。