什么是自旋锁 自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
/**
* 为什么用自旋锁：多个线程对同一个变量一直使用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;
}
}
