可重入锁(递归锁)
什么是可重入锁
- 指的是同一线程的外层函数获得锁之后,内层递归函数仍能获取该锁的代码。
- 在同一个线程在外层方法获取锁的时候,在进入内层方法会自动获取锁。
- 线程可以进入一个它已经拥有的锁所同步着的代码块!
- 也就是说,已经加锁的代码块中还有有锁方法调用,那么这个调用的方法也会获取这个锁。
- 锁定的是对象,如果获得锁了,那么被这个锁修饰的方法/代码块都可以进行访问。
// method01 是上锁了的,此时内部调用了 method02 方法,
// 此时虽然 method02 也是同步方法,但是调用 method01 之后,他俩共用 method01 的锁。
// 锁里套锁才算是可重入锁。
public synchronized void method01() {
method02();
}
public synchronized void method02() {
}
作用
- 最大作用就是用来避免死锁。
- 避免死锁说的是两个同步方法互相调用的时候,如果不可重入,会造成循环等待,造成死锁。
ReentrantLock类可重入锁
- 与 synchronized 关键字一样他俩默认都是非公平的可重入锁!
构造方法
public ReentrantLock() {
sync = new NonfairSync(); // 默认创建一个非公平锁
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync(); // 创建一个公平锁或非公平锁
}
测试案例
package JUC.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author zhaolimin
* @date 2021/11/14
* @apiNote ReenterLockDemo 测试类
*/
class Test01 {
Lock lock = new ReentrantLock();
public void get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 调用了 get() 方法");
System.out.println("此时锁为: " + this);
this.getIn();
} finally {
lock.unlock();
}
}
public void getIn() {
System.out.println(Thread.currentThread().getName() + "\t 调用了getIn() 方法");
System.out.println("此时锁为: " + this);
}
}
public class ReenterLockDemo {
public static void main(String[] args) {
Test01 test01 = new Test01();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
try {
test01.get();
} catch (Exception e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
}
/*
0 调用了 get() 方法
此时锁为: JUC.lock.Test01@2322e888
0 调用了getIn() 方法
此时锁为: JUC.lock.Test01@2322e888
1 调用了 get() 方法
此时锁为: JUC.lock.Test01@2322e888
1 调用了getIn() 方法
此时锁为: JUC.lock.Test01@2322e888
*/
Synchronized 关键字可重入锁
测试案例
package JUC.lock;
/**
* @author zhaolimin
* @date 2021/11/14
* @apiNote Synchronized 关键字可重入锁测试
*/
class Tickets {
public void book() throws Exception{
synchronized (this) {
System.out.println(Thread.currentThread().getName() + "\t 调用了 book() 方法");
System.out.println("此时锁为: " + this);
this.cancel();
}
}
public void cancel() throws Exception{
System.out.println(Thread.currentThread().getName() + "\t 调用了 cancel() 方法");
int index = 0;
while (true) {
System.out.println("此时锁为: " + this);
if (index == 5) {
break;
}
index ++ ;
}
}
}
public class SynchronizedDemo {
public static void main(String[] args) {
Tickets tickets = new Tickets();
for (int i = 0; i < 5; i++) {
new Thread(() -> {
try {
tickets.book();
} catch (Exception e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
}
/*
0 调用了 book() 方法
此时锁为: JUC.lock.Tickets@74c00d
0 调用了 cancel() 方法
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
1 调用了 book() 方法
此时锁为: JUC.lock.Tickets@74c00d
1 调用了 cancel() 方法
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
此时锁为: JUC.lock.Tickets@74c00d
*/
公平锁和非公平锁
是什么
- 公平锁:
- 多个线程按照申请锁的顺序来进行锁的获取,先来后到。
- 非公平锁:
- 多个线程获取锁的顺序不按照申请锁的顺序,会出现后申请的线程比先申请的线程先获取锁的情况。
- 高并发情况下,有可能会造成优先级反转或者饥饿现象。
两者区别
- 拿ReentrantLock来说。
- 并发包中的 ReentrantLock 可重入锁可以创建公平锁或非公平锁,默认是非公平锁。
public class LockDemo01 {
volatile int n = 0;
public void add() {
n++;
}
public static void main(String[] args) {
// 非公平锁
Lock lock1 = new ReentrantLock();
// 公平锁
Lock lock2 = new ReentrantLock(true);
}
}
-
公平锁在JAVA中来说:
- 在并发环境中,每个线程在获取锁的时候会先查看此锁维护的等待队列,如果为空,或者当前线程是等待队列的第一个,就占有锁,否则就会加入到等待队列中,按照FIFO的规则从队列中排队等锁。
- synchronized 也是一种公平锁。
-
非公平锁在JAVA中来说:
- 上来线程就可以直接尝试抢占锁,如果成功,直接获取锁,如果不成功,那就按照类似公平锁的方式来获取锁。
- 优点在于它的吞吐量大。
自旋锁
是什么
- 是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁。
- 获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务,使用这种锁会造成 busy-waiting。
- 优点是减少线程上下文切换的消耗。
- 缺点是循环会消耗CPU资源。
- 可以参考 Unsafe.getAndAddInt 方法。
测试案例
- 主要采用了 CAS 操作来实现。
package JUC.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author zhaolimin
* @date 2021/11/14
* @apiNote 自旋锁测试
*/
public class SpinLockDemo {
// 原子引用线程
AtomicReference<Thread> threadAtomicReference = new AtomicReference<>();
public void myLock() {
Thread thread = Thread.currentThread();
// 如果期望值是null,主内存中也是null,那主内存中threadAtomicReference的值就为thread
System.out.println(thread.getName()+ "线程\t 获取锁中。。。");
while (!threadAtomicReference.compareAndSet(null,thread)) {
}
System.out.println(thread.getName()+ "线程\t 获取锁成功,占用中。。。");
}
public void myUnLock() {
Thread thread = Thread.currentThread();
threadAtomicReference.compareAndSet(thread,null);
System.out.println(thread.getName()+ "线程\t 解锁成功。");
}
public static void main(String[] args) {
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(() -> {
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(8);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();
}, "t1").start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
spinLockDemo.myUnLock();
}, "t2").start();
}
}
/*
占用 8 秒 --------------------------
t1线程 获取锁中。。。
t1线程 获取锁成功,占用中。。。
3 秒后 t2 线程尝试获取锁 --------------------------
t2线程 获取锁中。。。
8 秒后 t1 线程释放锁 --------------------------
t1线程 解锁成功。
t2线程 获取锁成功,占用中。。。
t2线程 解锁成功。
*/
读写锁
- 拆开来,就是独占锁(写锁),共享锁(读锁)。
独占锁
- 指该锁一次只能被一个线程持有。
- 对 ReentrantLock类、synchronized 关键字来说都是独占锁。
共享锁
- 指该锁可可以被多个线程持有。
- 对 ReentrantReadWriteLocl类来说,读锁为共享锁,写锁为独占锁。
- 读锁的共享锁可以保证并发环境下线程读的效率。
- 写写、读写、写读的过程是互斥的。
ReentrantReadWriteLock类
两个重要方法
// 获取写锁,独占锁形式
public ReentrantReadWriteLock.WriteLock writeLock() {
return writerLock;
}
// 获取读锁,共享锁形式
public ReentrantReadWriteLock.ReadLock readLock() {
return readerLock;
}
案例
- 写操作 = 原子 + 独占
- 读读能共存,读写、写写不能共存。
package JUC.lock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author zhaolimin
* @date 2021/11/14
* @apiNote 读写锁测试类。
*/
class MyCache {
private volatile Map<String,Object> map= new HashMap<>(); // 满足可见性、禁止指令重排
private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put(String key, Object value) {
// 上独占锁写锁。
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在写入:" + key);
// 暂停0.3秒。
try {
TimeUnit.MICROSECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "\t 写入完成:" + key);
} finally {
readWriteLock.writeLock().unlock();
}
}
public void get(String key) {
// 上共享读锁
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在读取:" + key);
// 暂停0.3秒。
try {
TimeUnit.MICROSECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object result = map.get(key);
System.out.println(Thread.currentThread().getName() + "\t 读取完成:" + result );
} finally {
readWriteLock.readLock().unlock();
}
}
public void clearMap() {
map.clear();
}
}
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 1; i <= 5; i++) {
// 匿名内部类使用外部的局部变量,这个局部变量必须用final修饰来保证数据的一致性。
final int tempInt = i;
new Thread(() -> {
myCache.put(tempInt+"", tempInt+"");
}, String.valueOf(i)).start();
}
for (int i = 1; i <= 5; i++) {
// 匿名内部类使用外部的局部变量,这个局部变量必须用final修饰来保证数据的一致性。
final int tempInt = i;
new Thread(() -> {
myCache.get(tempInt+"");
}, String.valueOf(i)).start();
}
}
}
/*
2 正在写入:2
2 写入完成:2
1 正在写入:1
1 写入完成:1
3 正在写入:3
3 写入完成:3
4 正在写入:4
4 写入完成:4
5 正在写入:5
5 写入完成:5
1 正在读取:1
2 正在读取:2
3 正在读取:3
4 正在读取:4
5 正在读取:5
1 读取完成:1
5 读取完成:5
3 读取完成:3
2 读取完成:2
4 读取完成:4
*/
码云仓库同步笔记,可自取欢迎各位star指正:https://gitee.com/noblegasesgoo/notes
如果出错希望评论区大佬互相讨论指正,维护社区健康大家一起出一份力,不能有容忍错误知识。
—————————————————————— 爱你们的 noblegasesgoo