一、锁的分类
1.可重入锁、不可重入锁
可重入：线程A拿到锁资源，此时线程A尝试再次拿取同一把锁资源，是可以获取到的。
不可重入：线程A拿到锁资源，此时线程A尝试再次拿取同一把锁资源，无法获取到，因为锁被自身占用着，需要等自己将锁释放才能再次获取到。
（java中的synchronize、ReentrantLock、ReentrantReadWriteLock都是可重入锁）
2.乐观锁、悲观锁
乐观锁：线程获取不到锁资源时，会将该线程挂起（BLOCKED,WAITING），涉及到用户态和内核态的切换，而这种切换是非常消耗资源的。
- 用户态：JVM可以自行执行指令，不需要借助操作系统。
- 内核态：JVM不可以自行执行指令，需要借助操作系统才能执行。
悲观锁：线程获取不到锁资源时，会再次调度CPU重新尝试获取锁资源。
（java中的synchronize、ReentrantLock、ReentrantReadWriteLock都是悲观锁，cas是乐观锁的一种实现）
3.公平锁、非公平锁
公平锁：线程A拿到了锁资源，此时线程B来了没有拿到锁资源，线程B去排队，之后线程C又来了，他会排到线程B之后，当B拿到锁资源或者取消后才去竞争锁资源。
非公平锁：线程A拿到了锁资源，此时线程B来了没有拿到锁资源，线程B去排队，之后线程C又来了，他会先尝试去竞争一波锁资源，有可能会在B之前拿到锁资源。
（java中的synchronize是非公平锁，ReentrantLock、ReentrantReadWriteLock可以实现公平锁，也可以实现非公平锁）
4.互斥锁、共享锁
互斥锁：同一时间点，只有一个线程可以获取到当前锁资源。
共享锁：同一时间点，多个线程可以共享同一个锁资源。
（java中的synchronize、ReentrantLock是互斥锁，ReentrantReadWriteLock有互斥锁也有共享锁）
二、深入synchronize
1.类锁、对象锁
synchronize可以用于代码块或者方法上，是基于对象实现的。
- synchronize用于静态方法上，锁的是整个class类，因为全局只有一个（类锁）。
- synchronize用于非静态方法上，锁的是调用该方法的对象（对象锁）。
-
public
class
Demo01 {
-
-
public
static
void
main
(String[] args) {
-
//synchronize锁的是Demo01这个类，因为全局只有一个
-
Demo01.test1();
-
//synchronize锁的是demo01这个对象，因为每个对象的实例化都是不一样的
-
Demo01
demo01
=
new
Demo01();
-
demo01.test2();
-
}
-
-
public
static
synchronized
void
test1
() {
-
System.out.println(
"类锁");
-
}
-
-
private
synchronized
void
test2
() {
-
System.out.println(
"对象锁");
-
}
-
-
}
2.synchronize的优化
在jdk1.5的时候，推出了ReentrantLock锁，效率远高于synchronize，因此在jdk1.6中，对synchronize做了大量优化，效率和ReentrantLock很接近。
2.1.锁消除
在synchronize代码块中，如果不存在操作临界资源的情况下，也就是没必要进行加锁，这时会触发锁消除，即便写了synchronize也不会触发。
-
private
synchronized
void
test1
() {
-
//没有操作临界资源
-
//加锁无意义，可以认为这个方法的synchronize木有
-
}
2.2.锁膨胀
在循环的代码块中加入synchronize锁，会频繁的获取锁和释放锁，这样是非常消耗资源的，此时会触发锁膨胀，也就是将锁的范围扩大，避免频繁的获取锁和释放锁而带来不必要的消耗。
-
private
void
test2
() {
-
for (
int
i
=
0; i <
1000; i++) {
-
synchronized (
this) {
-
//频繁竞争锁资源
-
}
-
}
-
//这时会触发锁膨胀，扩大锁的范围
-
synchronized (
this){
-
for (
int
i
=
0; i <
1000; i++) {
-
-
}
-
}
-
}
2.3.锁升级
jdk1.6出现的ReentrantLock是基于cas乐观锁实现的，在锁竞争时，会先尝试获取锁资源，如果实在拿不到锁，才会将线程挂起。jdk1.6之前的synchronize是获取不到锁就将线程挂起，前面提到线程挂起涉及到用户态和内核态的切换，是非常消耗资源的，因此jdk1.6之前的synchronize性能是非常差的，因此在jdk1.6对synchronize做个锁升级的优化，会涉及到以下四个状态。
- 无锁、匿名偏向：当前对象创建后，还没有线程加入，对象没有锁存在
- 偏向锁：如果当前锁资源只有一个线程在频繁的获取锁和释放锁，那么当线程过来获取锁，只需要判断是否为当前线程：
- 若是，则直接拿到当前锁资源
- 若不是当前线程，会基于cas的方式，尝试将偏向锁指向当前线程，若获取不到则升级为轻量级锁（出现了锁的竞争）
- 轻量级锁：采用自旋以cas的方式频繁的获取锁（自适应自旋锁）
- 成功获取到则拿着锁资源走
- 未获取到，自旋达到了一定次数，触发锁升级，升级为重量级锁
- 重量级锁：采用最传统的synchronize方式，若获取不到锁，就将线程挂起（用户态&内核态）
锁升级状态的转变
三、ReentrantLock
1.ReentrantLock和synchorized的区别
- ReentrantLock是一个类，synchronized是一个关键字
- ReentrantLock是基于cas实现的，synchronized是基于ObjectMonitor实现的
- 在线程竞争锁资源激烈的情况下，ReentrantLock效率较高，因为其内部不存在锁升级的概念，synchronized升级为重量级锁时效率较低
- ReentrantLock功能更全面，可以支持公平锁和非公平锁，还可以指定锁等待的时间
2.AQS概述
AQS是AbstractQueuedSynchronizer的缩写，是一个抽象类，属于JUC的一个基类，JUC下的很多内容都是通过AQS实现的，例ReentrantLock，ThreadPoolExecutor，阻塞队列，CountDownLatch，Semaphore，CyclicBarrier等等都是基于AQS实现。
2.1.AQS的内部结构
- 由volatile修饰的state成员变量，保证了可见性和有序性（禁止指令重排）
- 双向链表Node头节点和尾节点
3.ReentrantLock加锁流程（三种）
3.1.lock()方法
ReentrantLock可以指定公平锁和非公平锁，默认为非公平锁，在构造函数里进行指定。
如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁。
-
public
static
void
main
(String[] args) {
-
//默认无参构造方法，非公平锁
-
ReentrantLock
reentrantLock
=
new
ReentrantLock();
-
//有参构造方法，非公平锁
-
//ReentrantLock reentrantLock1 = new ReentrantLock(true);
-
reentrantLock.lock();
-
try {
-
System.out.println(
"业务代码");
-
}
finally {
-
reentrantLock.unlock();
-
}
-
}
3.2.tryLock()方法
- tryLock()：尝试获取锁资源，如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false
- tryLock(long timeout, TimeUnit unit)，尝试获取锁资源，若没获取到，在指定时间内再次不断获取锁资源，并返回获取结果
-
public
static
void
main
(String[] args)
throws InterruptedException {
-
ReentrantLock
reentrantLock
=
new
ReentrantLock();
-
boolean
result
= reentrantLock.tryLock(
5L, TimeUnit.MINUTES);
-
try {
-
System.out.println(
"加锁状态:" + result);
-
System.out.println(
"业务代码");
-
}
finally {
-
reentrantLock.unlock();
-
}
-
}
3.3.lockInterruptibly()方法
与tryLock类似，区别在于拿不到锁资源，就死等，等到锁资源释放后，被唤醒，或者是被中断唤醒。
如果获取了锁资源立即返回，如果没有获取锁资源，当前线程处于休眠状态，直到获取锁资源，或者当前线程被别的线程中断。
-
public
static
void
main
(String[] args)
throws InterruptedException {
-
//默认无参构造方法，非公平锁
-
ReentrantLock
reentrantLock
=
new
ReentrantLock();
-
//有参构造方法，非公平锁
-
//ReentrantLock reentrantLock1 = new ReentrantLock(true);
-
reentrantLock.lockInterruptibly();
-
try {
-
System.out.println(
"业务代码");
-
}
finally {
-
reentrantLock.unlock();
-
}
-
}
4.ReentrantLock释放锁
四、ReentrantReadWriteLock
传统的synchronized和ReentrantLock都是互斥锁，如果有一个读多写少的操作，还要保证线程安全的问题，使用互斥锁效率是非常低的，因此出现了ReentrantReadWriteLock读写锁，在读读的操作下使用共享锁，在写写和读写的操作下使用互斥锁，提升了效率。
-
public
class
ReadWriteLockDemo {
-
-
public
static ReentrantReadWriteLock reentrantReadWriteLock =
new ReentrantReadWriteLock();
-
-
public
static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
-
-
public
static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
-
-
public static void main(String[] args) {
-
new Thread(() -> {
-
readLock.
lock();
-
try {
-
System.
out.println(
"子线程加读锁");
-
Thread.sleep(
50000);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
finally {
-
readLock.unlock();
-
}
-
}).start();
-
-
readLock.
lock();
-
System.
out.println(
"主线程加读锁");
-
try {
-
Thread.sleep(
500);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
finally {
-
readLock.unlock();
-
}
-
}
-
-
}
本文转载于如有侵权删：https://blog.csdn.net/qq_41449402/article/details/128712425
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
