单机下：

 

只适用于单机环境下（单个JVM），多个客户端访问同一个服务器

1.synchronized

package com.cloud.SR.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class TestConrtoller1 {
    @Value("${server.port}")
    private String serverPort;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("/buy1")
    public String shopping(){
        synchronized (this){

            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int total = result == null? 0 :Integer.parseInt(s);
            if(total > 0){
                int realTotal = total - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realCount ));
                System.out.println("剩余商品为："+realCount +",提供服务的端口号："+serverPort);
                return "剩余商品为："+realTotal +",提供服务的端口号："+serverPort;
            }else{
                System.out.println("购买商品失败！");
            }
            return "购买商品失败！";
        }
    }
}

2.ReentrantLock

@RestController
public class TestConrtoller2 {
    @Value("${server.port}")
    private String serverPort;

    // 使用ReentrantLock锁解决单体应用的并发问题
    Lock lock = new ReentrantLock();

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/buy2")
    public String index() {

        lock.lock();
        try {
            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                int realTotal = total - 1;
                stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "，服务端口为:"+serverPort);
                return "购买商品成功，库存还剩：" + realTotal + "，服务端口为："+serverPort;
            } else {
                System.out.println("购买商品失败！");
            }
        } catch (Exception e) {
            lock.unlock();
        } finally {
            lock.unlock();
        }
        return "购买商品失败！";
    }
}

分布式下：

而在服务器分布式集群下，，单个服务器的synchronized和ReentrantLock

 

1.SETNX

SET key value [EX seconds] [PX milliseconds] [NX|XX]

• EX seconds – 设置键key的过期时间，单位时秒
• PX milliseconds – 设置键key的过期时间，单位时毫秒
• NX – 只有键key不存在的时候才会设置key的值
• XX – 只有键key存在的时候才会设置key的值

例子：

1.set lock01 01 NX ：意思就是说只要谁把key为lock01的值设置为01且key不存在的时候就能拿到锁

2. set lock01 01 NX EX 30 ：在例1的基础上把锁设置的时间设置为30秒后过期。避免有服务挂了而没有释放锁的情况、或者业务处理完但一直拿着锁不释放导致死锁。

项目中使用SETNX：

• template.opsForValue().setIfAbsent()

测试的话就得本机模拟集群，当然有虚拟机的也可以用两台虚拟机，但此处用两台JVM即可完成简易集群
本机实现集群的可以看这篇文章：http://t.csdn.cn/jvZFx

 先让集群跑起来，然后启动Nginx，再通过Jmeter实现高并发的秒杀环节

 用template.opsForValue().setIfAbsent()命令进行加锁。加上了过期时间后就解决了key无法删除的问题，但如果key设置的时间太短，当业务处理的时间长于key设置的时间，key过期后其他请求就可以设置这个key而当这个线程再回来处理这个程序的时候就会把人家设置的key给删除了，因此我们规定谁设置的锁只能由谁删除。

finally {
            // 谁加的锁，谁才能删除
            if(template.opsForValue().get(REDIS_LOCK).equals(value)){
                template.delete(REDIS_LOCK);
            }

而新的问题就是finally块的判断和del删除操作不是原子操作，并发的时候也会出问题。因此采用lua（原子性）来进行删除

finally {
            // 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除

            Jedis jedis = null;
            try{
                jedis = RedisUtils.getJedis();

                String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }catch (Exception e){

            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }

总的代码： 

@RestController
public class TestConrtoller3 {
    @Value("${server.port}")
    private String serverPort;

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate stringtemplate;

    @RequestMapping("/buy3")
    public String shopping(){

        // 每个人进来先要进行加锁，key值为"good_lock",且用UUID保证每个人的锁不同
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 为key加一个过期时间
            Boolean flag = stringtemplate.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = stringtemplate.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                stringtemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "，服务端口为"+serverPort);
                return "购买商品成功，库存还剩：" + realTotal + "服务端口为"+serverPort;
            } else {
                System.out.println("购买商品失败");
            }
            return "购买商品失败！";
        }finally {
            // 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除
            Jedis jedis = null;
            try{
                jedis = RedisUtils.getJedis();

                String script = "if redis.call('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }catch (Exception e){

            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }
    }
}

2.Redisson(推荐)

考虑缓存续命，以及Redis集群部署下，异步复制造成的锁丢失：主节点没来得及把刚刚set进来这条数据给从节点，就挂了。所以直接上RedLock的Redisson落地实现

@RestController
public class TestConrtoller4 {
    @Value("${server.port}")
    private String serverPort;

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate stringtemplate;

    @Autowired
    Redisson redisson;

    @RequestMapping("/buy4")
    public String shopping(){

        RLock lock = redisson.getLock(REDIS_LOCK);
        lock.lock();

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            String result = stringtemplate.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长
                int realTotal = total - 1;
                stringtemplate.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为"+serverPort);
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为"+serverPort;
            } else {
                System.out.println("购买商品失败");
            }
            return "购买商品失败";
        }finally {
            if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

Redis工具类

 
import com.myfutech.common.util.constant.RedisPrefix;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
 
import java.nio.charset.StandardCharsets;
import java.util.UUID;
 
 
/**
 * 基于redis分布式锁
 */
@Slf4j
public class RedisLockUtils {
 
    /**
     * 默认轮休获取锁间隔时间， 单位：毫秒
     */
    private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100;
 
    private static final String UNLOCK_LUA;
 
    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }
 
    /**
     * 获取锁，没有获取到则一直等待，异常情况则返回null
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lock(RedisTemplate redisTemplate, final String key, long expire){
        return lock(redisTemplate, key, expire, -1);
    }
 
    /**
     * 获取锁，acquireTimeout时间内没有获取到，则返回null，异常情况返回null
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lock(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
        try {
            return acquireLock(redisTemplate, key, expire, acquireTimeout);
        } catch (Exception e) {
            log.error("acquire lock exception", e);
        }
        return null;
    }
 
    /**
     * 获取锁，没有获取到则一直等待，没有获取到则抛出异常
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire){
        return lockFailThrowException(redisTemplate, key, expire, -1);
    }
 
    /**
     * 获取锁，到达超时时间时没有获取到，则抛出异常
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
        try {
            String lockId = acquireLock(redisTemplate, key, expire, acquireTimeout);
            if (lockId != null) {
                return lockId;
            }
            throw new RuntimeException("acquire lock fail");
        } catch (Exception e) {
            throw new RuntimeException("acquire lock exception", e);
        }
    }
 
    private static String acquireLock(RedisTemplate redisTemplate, String key, long expire, long acquireTimeout) throws InterruptedException {
        long acquireTime = -1;
        if (acquireTimeout != -1) {
            acquireTime = acquireTimeout * 1000 + System.currentTimeMillis();
        }
        synchronized (key) {
            String lockId = UUID.randomUUID().toString();
            while (true) {
 
                if (acquireTime != -1 && acquireTime < System.currentTimeMillis()) {
                    break;
                }
                //调用tryLock
                boolean hasLock = tryLock(redisTemplate, key, expire, lockId);
 
                //获取锁成功
                if (hasLock) {
                    return lockId;
                }
                Thread.sleep(DEFAULT_ACQUIRE_RESOLUTION_MILLIS);
            }
        }
        return null;
    }
 
 
    /**
     *  释放锁
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param lockId            当前锁唯一id
     */
    public static void unlock(RedisTemplate redisTemplate, String key, String lockId) {
        try {
            RedisCallback<Boolean> callback = (connection) ->
                    connection.eval(UNLOCK_LUA.getBytes(StandardCharsets.UTF_8),ReturnType.BOOLEAN, 1,
                            (RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8), lockId.getBytes(StandardCharsets.UTF_8));
            redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("release lock exception", e);
        }
    }
 
    /**
     * 获取当前锁的id
     *
     * @param key       redis key
     * @return          当前锁唯一id
     */
    public static String get(RedisTemplate redisTemplate, String key) {
        try {
            RedisCallback<String> callback = (connection) -> {
                byte[] bytes = connection.get((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8));
                if (bytes != null){
                    return new String(bytes, StandardCharsets.UTF_8);
                }
                return null;
            };
            return (String)redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("get lock id exception", e);
        }
        return null;
    }
 
    private static boolean tryLock(RedisTemplate redisTemplate, String key, long expire, String lockId) {
        RedisCallback<Boolean> callback = (connection) ->
        connection.set((RedisPrefix.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8),
                lockId.getBytes(StandardCharsets.UTF_8), Expiration.seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
        return (Boolean)redisTemplate.execute(callback);
    }
}