1、ReentrantLock是什么？
它其实就是一个锁，
我们已经有了synchronized这个锁了，为什么还要开发出一个ReentrantLock这个锁尼？
我认为这个锁是为了用户更好的控制的锁，而synchronized是jvm提供的锁，它释放锁是不受我们控制的。
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题
。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。
需要明确的几个问题：
- synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果 再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
- 无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
- 每个对象只有一个锁（lock）与之相关联。
- 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
synchronized关键字的作用域有二种：
-
某个
对象实例内
，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线 程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； -
某个类的范围
，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
1.1、synchronized与lock锁之间的区别？
- synchronized是jvm层面的，而lock是一个类；
- synchronized它的加锁后，释放锁不是我们能够控制的，而lock什么时候释放锁是由我们决定的；
- synchronized它一般和object的wait、notify、notifyAll方法联合一起使用，而lock一般是和Condition类的await、signal、signalAll使用；
- Lock可以让等待锁的线程响应中断，而synchronized不会，线程会一直等待下去。
- 通过Lock可以知道线程有没有拿到锁，而synchronized不能。
- Lock能提高多个线程读操作的效率。
ReentrantLock是一个可重入的锁、公平锁、非公平锁，他到底是怎么实现的尼？
下面我们就按照源码来分析一下ReentrantLock类
2、ReentrantLock类的主要属性
// ReentrantLock实现了Lock接口，实现了其方法
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** Synchronizer providing all implementation mechanics */
// Sync 这个类是Reentrantlock的内部类 这是实现锁的关键
private final Sync sync;
//根据传入的参数，来判断是创建公平锁还是非公平锁 FairSync 和NonfairSync都是ReentrantLock的内部类
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 在不传参数的时候获得的是非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
}
2.1、java.util.concurrent.locks.ReentrantLock.Sync类源码解析
// 他继承了AbstranctQueuedSynchronized（同步器），这个类是提供了一个属性status(volatile修饰的)，并用CAS来对这个属性进行操作，来达到多线程下，是线程安全的
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
/**
* Performs {@link Lock#lock}. The main reason for subclassing
* is to allow fast path for nonfair version.
*/
abstract void lock();
/**
* Performs non-fair tryLock. tryAcquire is implemented in
* subclasses, but both need nonfair try for trylock method.
*/
// 非公平锁加锁的逻辑
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 这个是非公平锁的源码，只要是等待的线程都可以抢占，没有先后顺序，谁抢到就是谁的，而公平锁是会判断是不是头节点
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {// 可重入锁的源码，判断枷锁的是不是当前线程
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// 释放锁
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
protected final boolean isHeldExclusively() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
// Methods relayed from outer class
// 获得枷锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
// 判断当前线程得到锁了吗
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
// 这个是判断枷锁了吗
final boolean isLocked() {
return getState() != 0;
}
/**
* Reconstitutes the instance from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
2.2、java.util.concurrent.locks.ReentrantLock.NonfairSync源码 （非公平锁）
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 这个会调java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire方法，
//最后调用下面的tryAcquire方法
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
// 会调上面Sync类的方法
return nonfairTryAcquire(acquires);
}
}
2.3、java.util.concurrent.locks.ReentrantLock.FairSync源码（公平锁）
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 这个是判断当前线程是不是头节点，这个也是和非公平锁最大的区别
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {// 可重入锁的源码
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
3、ReentrantLock实现锁的机制
是依赖了AbstrantQueuedSynchronizer同步器来实现的，具体请参考
https://blog.csdn.net/wojiao228925661/article/details/100086245
这篇文章
参考：
版权声明：本文为wojiao228925661原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。