什么是自旋锁
自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
/**
* 为什么用自旋锁：多个线程对同一个变量一直使用CAS操作，那么会有大量修改操作，
* 从而产生大量缓存一致性流量，因为每一次CAS操作都会发出广播通知其他处理器，从而影响程序的性能。
*
* 自旋不是阻塞，阻塞被唤醒的代价高，性能较差。自旋是执行空代码，虽然效率高，但是会一直占用CPU，
* 最好是很短时间内获得。
*
* 自旋锁：从等待到解锁，线程一直处于running状态，没有上下文切换。
* 注意死递归、死循环导致死锁。
*/
自旋锁+redis
1、导入redis锁
com.baomidou
lock4j-redisson-spring-boot-starter
2.2.2
2、业务实现
自旋锁+redis
1、导入redis锁
com.baomidou
lock4j-redisson-spring-boot-starter
2.2.2
2、业务实现
@Slf4j
@RunWith(SpringRunner.class)
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = TaskApplication.class)
public class ExceptionTest {
@Resource private LockTemplate lockTemplate; private final String key = "work_redis_default_lock_test"; @Test public void test() { LockInfo lockInfo = null; try { //请求超时时间小于等于0L,框架会用默认的请求超时时间,第四个参数决定lock方法用框架里面的自旋锁。设置超时时间。请求时间和过期时间是不一样的概念。 lockInfo = lockTemplate.lock(key, 50000, 0L, RedissonLockExecutor.class); if (null == lockInfo) { log.warn("未抢到锁，结束， key:{}", key); return; } //模拟业务 long startTime = System.currentTimeMillis(); Thread.sleep(5000); long endTime = System.currentTimeMillis(); log.info("startTime:{}, endTime:{}, user time:{}", startTime, endTime, endTime - startTime); } catch (Exception e) { log.error("e:", e); } finally { //释放锁 lockTemplate.releaseLock(lockInfo); } }
}
3、结果
2022-07-26 16:47:28.920 INFO 23188 — [ main] ExceptionTest : startTime:1658825243919, endTime:1658825248920, user time:5001
4、dubug
在dubug到这里的时候，实际上，redis已经加了锁。
key是我们定义的key，里面的key类型是hash,key随机产生，value 1。
上锁，其他人无法进来，在外面等待。
设置超时、过期时间，如果中途中断了，这个key也会过期，这样不会影响到其他线程访问，是防止死锁的重要手段。
最后执行释放锁，那redis key会被销毁。
5、源码研究
public LockInfo lock(String key, long expire, long acquireTimeout, Class<? extends LockExecutor> executor) {
acquireTimeout = acquireTimeout < 0L ? this.properties.getAcquireTimeout() : acquireTimeout;
long retryInterval = this.properties.getRetryInterval();
LockExecutor lockExecutor = this.obtainExecutor(executor);
log.debug(String.format(“use lock class: %s”, lockExecutor.getClass()));
expire = !lockExecutor.renewal() && expire <= 0L ? this.properties.getExpire() : expire;
int acquireCount = 0;
String value = LockUtil.simpleUUID();
long start = System.currentTimeMillis();
try { do { ++acquireCount; Object lockInstance = lockExecutor.acquire(key, value, expire, acquireTimeout); if (null != lockInstance) { return new LockInfo(key, value, expire, acquireTimeout, acquireCount, lockInstance, lockExecutor); } TimeUnit.MILLISECONDS.sleep(retryInterval); } while(System.currentTimeMillis() - start < acquireTimeout); return null; } catch (InterruptedException var15) { log.error("lock error", var15); throw new LockException(); } }
实际上这里在执行自旋锁，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
do {
++acquireCount;
Object lockInstance = lockExecutor.acquire(key, value, expire, acquireTimeout);
if (null != lockInstance) {
return new LockInfo(key, value, expire, acquireTimeout, acquireCount, lockInstance, lockExecutor);
}
TimeUnit.MILLISECONDS.sleep(retryInterval); } while(System.currentTimeMillis() - start < acquireTimeout);
自旋锁里面getlock trylock获取锁
public RLock acquire(String lockKey, String lockValue, long expire, long acquireTimeout) { try { RLock lockInstance = this.redissonClient.getLock(lockKey); boolean locked = lockInstance.tryLock(acquireTimeout, expire, TimeUnit.MILLISECONDS); return (RLock)this.obtainLockInstance(locked, lockInstance); } catch (InterruptedException var9) { return null; } }
