对于经常开发Web的Coder们，经常会有这样的需求，就是在多机的分布式环境下，有时候需要限制多台机器上的请求修改同一份资源。对于单机的环境下，我们通常可以用同步或者锁去避免多线程下的竞态条件。以java为例，我们可以用synchronized或者ReentrantLock，去做资源访问的同步。但这是JVM和操作系统提供给我们的特性，但是对于分布式环境下我们没有这些便利条件。所以我们需要引入一个外部的Observer去实现这样的一个分布式锁，Zookeeper是一个比较好的解决方案，但是Zookeeper还是比较重的，我们可以用Redis实现这样一个锁。
乐观锁基于CAS思想，是不具有互斥性，不会产生锁等待而消耗资源，但是需要反复的重试，但也是因为重试的机制，能比较快的响应。在实现CAS之前，需要了解一下Redis的事务机制。
Redis事务：
我们可以用Mysql事务机制来理解Redis的事务机制，但也有所不同，Mysql的事务的形式如下：
openSession()
update()
insert()
commit()
如果在update和insert之间出现错误，那么会触发rollback()，Redis的事务用到了MULTI和EXEC命令，事务的形式如下：
MULTI
SET
HSET
EXEC
和Mysql的事务不同，Redis会将所有EXEC命令之前的命令放入一个QUEUE中，当遇到EXEC时批量执行QUEUE中的命令，但是 Redis的事务是不支持回滚的，它只是顺序的执行命令，并批量返回结果，但是对于极端情况下，事务在没有完全执行完时宕机，导致事务日志只写入部分，这样在重启时会产生错误，用aof的修复工具修复后可以进行启动。
在了解了事务机制后，我们还不足以实现乐观锁，还需要了解一个命令——Watch，Watch命令可以监控Redis中的一个key，当Key发生变化时终止事务的提交。先看一个正确的例子：
127.0.0.1:6379> set locktest 1
OK
127.0.0.1:6379> get locktest
"1"
127.0.0.1:6379> watch locktest
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set locktest 3
QUEUED
127.0.0.1:6379> exec
1) OK
127.0.0.1:6379> get locktest
"3"
127.0.0.1:6379>
但是在multi的过程中如果locktest的值发生变化又会怎样？
127.0.0.1:6379> set locktest 1
OK
127.0.0.1:6379> get locktest
"1"
127.0.0.1:6379> watch locktest
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set locktest 3
QUEUED
127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get locktest
"2"
127.0.0.1:6379>
这里我们用另一个Client在Multi之后将locktest修改为2，课件在执行事务的时候返回为nil，表示执行失败。
那么我们就可以用上述两种命令实现一个乐观锁，代码如下：
package com.redis.lock;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;
/**
* topic:利用redis的事务，实现一个乐观锁
*
* @author zhiming
*
*/
public class RedisWatchLock {
private static final String redisHost = "10.0.5.86";
private static final int port = 6381;
private static JedisPoolConfig config;
private static JedisPool pool;
private static ExecutorService service;
private static int ThLeng=10;
private static CountDownLatch latch;
private static AtomicInteger Countor = new AtomicInteger(0);
static{
//利用Redis连接池，保证多个线程利用多个连接，充分模拟并发性
config = new JedisPoolConfig();
config.setMaxIdle(10);
config.setMaxWaitMillis(1000);
config.setMaxTotal(30);
pool = new JedisPool(config, redisHost, port);
//利用ExecutorService 管理线程
service = Executors.newFixedThreadPool(10);
//CountDownLatch保证主线程在全部线程结束之后退出
latch = new CountDownLatch(ThLeng);
}
public static void main(String args[]){
int ThLeng = 10;
String ThreadNamePrefix = "thread-";
Jedis cli = pool.getResource();
cli.del("redis_inc_key");//先删除既定的key
cli.set("redis_inc_key", String.valueOf(1));//设定默认值
for(int i =0;i<ThLeng;i++){
Thread th = new Thread(new TestThread(pool));
th.setName(ThreadNamePrefix+i);
System.out.println(th.getName()+"inited...");
service.submit(th);
}
service.shutdown();
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("all sub thread sucess");
System.out.println("countor is "+Countor.get());
String countStr = cli.get("redis_inc_key");
System.out.println(countStr);
}
public static class TestThread implements Runnable {
private String incKeyStr = "redis_inc_key";
private Jedis cli;
private JedisPool pool;
public TestThread(JedisPool pool) {
cli = pool.getResource();
this.pool = pool;
}
public void run() {
try{
for (int i = 0; i < 100; i++) {
actomicAdd();
}
}catch(Exception e){
pool.returnBrokenResource(cli);
}
finally{
pool.returnResource(cli);
latch.countDown();
}
}
public void actomicAdd(){
boolean flag =true;
while(flag){
cli.watch(incKeyStr);
String countStr = cli.get("redis_inc_key");
int countInt = Integer.parseInt(countStr);
int expect = countInt+1;
Transaction tx = cli.multi();
tx.set(incKeyStr, String.valueOf(expect));
List<Object> list = tx.exec();
//如果事务失败了exec会返回null
if(list==null){
System.out.println("multi shut down");
continue;
}
else{
//如果达到期望值那么结束while循环
flag=false;
}
System.out.println("my expect num is "+expect);
System.out.println("seting....");
}
Countor.incrementAndGet();
}
}
}
这样我们就利用Redis实现了一个类似于Java 的原子类的功能。在实际的Web开发中，我们可以利用redis来解决资源重复修改或争用的问题。
