1. 单机锁
-
在多线程环境中，如果多个线程同时访问共享资源，会发生数据竞争，可能会导致出现脏数据或者系统问题，威胁到程序的正常运行；
-
为了保证共享资源被安全地访问，需要使用互斥操作对共享资源进行保护，即同一时刻只允许一个线程访问共享资源，其他线程需要等待当前线程释放后才能访问；
1.1 Synchronized
-
synchronized也称之为“同步锁”，它的作用是保证在同一时刻，被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果；
-
synchronized是单机锁，基于JVM实现，状态维护在对象头，只能保证单服务器内JVM的不同线程同步，不能用做分布式环境中的线程同步；
Synchronized的使用：
-
修饰一个代码块：被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
public void method() {
synchronized(this) {
// todo
}
}-
修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
public synchronized void method() {
// todo
}-
修饰一个静态的方法：其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
public synchronized static void method() {
// todo
}-
修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象；
class ClassName {
public void method() {
synchronized(ClassName.class) {
// todo
}
}
}-
synchronized示例：
/**
* synchronized同步
*/
class SyncThread implements Runnable {
private static int count;
public SyncThread() {
count = 0;
}
public static void method() {
synchronized(SyncThread.class) {
for (int i = 0; i < 5; i ++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public synchronized void run() {
method();
}
}1.2 ReentrantLock
-
ReentrantLock是单机锁，基于JDK实现，状态使用volatile维护；
-
ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”；
-
ReentrantLock锁在同一个时间点只能被一个线程锁持有；可重入表示，ReentrantLock锁可以被同一个线程多次获取；
-
ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的，在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”是不管自己是不是在队列的开头都会获取锁；
ReentrantLock的的使用：
-
lock：获取锁，获取不到就阻塞线程
public void lock() {
sync.lock();
}-
unlock：释放锁
public void unlock() {
sync.release(1);
}-
tryLock：尝试获取锁，立即返回获取结果，不会阻塞线程
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}-
tryLock：设置超时时间参数，超时时间内获取不到锁就等待，直到超过超时时间
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}-
tryLock示例：
public static void demo() throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(getRunnable(lock), "t1");
Thread t2 = new Thread(getRunnable(lock), "t2");
hread t3 = new Thread(getRunnable(lock), "t3");
Thread.sleep(2000);
t1.start();
t2.start();
t3.start();
}
private static Runnable getRunnable(ReentrantLock lock) {
return () -> {
String thName = Thread.currentThread().getName();
System.out.println("线程：" + thName + " 竞争锁");
try {
while (true) {
if (lock.tryLock()) {
System.out.println("线程：" + thName + " 获取锁，执行任务");
long start = System.currentTimeMillis();
Thread.sleep((long) (Math.random() * 10000));
System.out.println("线程：" + thName + " 完成任务耗时：" + (System.currentTimeMillis() - start));
break;
} else {
System.out.println("线程：" + thName + " 锁已被持有，先干点别的吧");
Thread.sleep(5000);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println("线程：" + thName + " 释放锁=====================");
lock.unlock();
}
};
}1.3 Synchronized和ReentrantLock的区别
-
用法不同：synchronized可用来修饰普通方法、静态方法和代码块，而ReentrantLock只能用于代码块；
-
锁的机制不同：synchronized会自动加锁和释放锁，而ReentrantLock需要手动加锁和释放锁；
-
锁类型不同：synchronized属于非公平锁，而ReentrantLock默认为非公平锁也可以指定为公平锁；
-
响应中断不同：synchronized不能响应中断，如果发生了死锁，会一直等待下去，而ReentrantLock可以响应中断并释放锁，从而解决死锁的问题；
-
底层实现不同：synchronized是JVM层面通过监视器（Monitor）实现的，而ReentrantLock是通过AQS（AbstractQueuedSynchronizer）程序级别的 API 实现的；
2. 分布式锁
2.1 分布式锁概念
在分布式系统下，不同的 服务端/客户端 通常运行在不同的JVM进程上，如果要使多个JVM进程共
享同一份资源，使用本地锁就没有办法实现资源的互斥访问了；
此时，就需要使用分布式锁了，分布式锁可以使不同JVM进程中的多个线程获取到同一把锁，进而
实现共享资源的互斥访问。
分布式锁需要满足的条件
-
互斥：任意一个时刻，锁只能被一个线程持有；
-
高可用：当一个锁服务出现问题，能够自动切换到另外一个锁服务。并且，即使释放锁的代码逻辑出现问题，锁最终一定还是会被释放，不会影响其他线程对
共享资源的访问，这一般是通过超时机制实现的；
-
可重入：一个节点获取了锁之后，还可以再次获取锁；
-
高性能：获取和释放锁的操作应该快速完成，并且不应该对整个系统的性能造成过大影响；
-
非阻塞：如果获取不到锁，不能无限期等待，避免对系统正常运行造成影响；
2.2 Redis分布式锁
2.3 Redisson分布式锁
基于redis setNX实现的分布式锁存在以下问题
-
不可重入：同一个线程无法多次获取同一把锁；
-
不可重试：获取锁如果失败就会返回false，没有重试机制；
-
超时释放：如果业务执行比较耗时，任务仍在执行中redis锁超时被释放；
-
死锁：锁正处于锁住的状态时，负责储存这个分布式锁的redis节点宕机，这个锁就会出现死锁状态；
2.3.1 Redisson概念
Redisson 是架设在Redis基础上的一个Java驻内存数据网格框架, 为使用者提供了一系列具有分布式特性的API；
2.3.2 Redisson的使用
引入依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.17.0</version>
</dependency>Redisson配置
@Configuration
public class RedissonConfig {
@Bean(destroyMethod = "shutdown")
public RedissonClient redisson() {
// 创建配置
Config config = new Config();
config.setCodec(new JsonJacksonCodec());
config.useSingleServer()
.setAddress("redis://127.0.0.1:6379")
.setPassword("123456");
// 创建RedissonClient对象
return Redisson.create(config);
}
}示例
@autowire
private RedissonClient redissonClient;
// tryLock
public void test01 {
RLock lock = redissonClient.getLock("myLock");
// 尝试获取锁，三个参数的意思是：waitTime（获取锁的最大等待时间），leaseTime（锁自动释放的时间），unit（前两种时间的单位）
boolean isLock = lock.tryLock(1, -1, TimeUnit.SECONDS);
if (isLock) {
try {
// 业务代码
} finally {
// 释放锁,判断要解锁的key是否已被锁定并且是否被当前线程保持
if (lock.isLocked() && lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
// lock
public void test02 {
// 获取分布式锁
RLock lock = redissonClient.getLock("myLock");
try {
lock.lock();
// 业务代码
// ...
} finally {
// 释放锁,判断要解锁的key是否已被锁定并且是否被当前线程保持
if (lock.isLocked() && lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}2.3.3 Redisson看门狗策略
看门狗策略是一种自动检测并处理过期键的机制，也就是说，如果线程没有执行完，那么redisson会自动给redis中的目标key延长超时时间；
看门狗默认加锁时长30秒，也可以通过修改Config.lockWatchdogTimeout来指定，每隔10秒从新刷新加锁时间；
看门狗是基于Redis的“WATCH”命令实现，通过在Redisson库中创建一个监视器（Watch Dog）来监控Redis服务器上的指定键；
方法示例：
// 拿锁失败时会不停的重试
RLock lock = redissonClient.getLock("key");
// 具有Watch Dog自动延期机制, 每隔10秒续到30s
lock.lock();
// 尝试拿锁10s后，没有Watch Dog
lock.lock(10, TimeUnit.SECONDS);
// 尝试拿锁10s后停止重试, 返回false, 具有Watch Dog自动延期机制, 默认续30s
boolean res1 = lock.tryLock(10, TimeUnit.SECONDS);
// 尝试拿锁100s后停止重试, 返回false, 没有Watch Dog, 10s后自动释放
boolean res2 = lock.tryLock(100, 10, TimeUnit.SECONDS);2.3.4 Redisson死锁的原因
-
逻辑错误 逻辑错误是导致Redisson死锁的主要原因之一。当多个进程试图获取同一个资源时，如果它们没有正确地处理锁的释放，就有可能导致死锁。
例如，一个进程获取了资源A的锁，但在使用后忘记释放锁，并且其他进程也在等待资源A的锁；
-
网络问题 网络问题也可能导致Redisson死锁。当网络连接中断或延迟时，进程无法及时获取锁或释放锁，这可能导致其他进程一直等待锁，最终导致死锁；
-
锁超时设置不当 Redisson允许为锁设置超时时间。如果锁超时时间设置得太长，就可能导致死锁。因为即使持有锁的进程崩溃或意外终止，其他进程也无法获取锁；
2.3.5 避免Redisson死锁的方法
-
合理设置锁超时时间 合理设置锁的超时时间，确保在一定时间内能够释放锁。这样即使持有锁的进程崩溃或意外终止，其他进程也有机会获取锁；
-
使用锁续约机制 Redisson提供了锁续约机制，可以在持有锁的进程执行期间定期延长锁的超时时间。这样可以防止锁过期，同时减少死锁的风险；
-
增加锁的粒度 如果可能的话，可以尝试将锁的粒度减小，使得每个锁只针对一个较小的资源进行操作。这样可以减少多个进程之间竞争同一个锁的情况，减少死锁的概率；
-
使用RedLock算法 RedLock是一种分布式锁算法，可以在多个Redis实例之间实现分布式锁。它通过使用多个Redis节点进行锁的获取和释放，提高了系统的可用性和安全性；
扫一扫
899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
