什么是自旋锁 自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。

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