最近觉着自己对java的一些高级用法不太了解,所以抽点时间来学习一下JUC锁机制。
本文要点:
- 共享锁和独占锁
- 独占锁中的公平锁和非公平锁
- 公平/非公平锁 获取机制
- 锁和synchronized的区别
1. 共享锁和独占锁
共享锁:顾名思义,是指一个锁能够被多个线程共享使用。
在java中,有类ReentrantReadWriteLock.ReadLock
,CyclicBarrier
,CountDownLatch
,Semaphore
独占锁:是指一次只能被一个线程占用
在java中,有类ReentrantLock
,ReentrantReadWriteLock.WriteLock
在java中,AQS->AbstractQueuedSynchronizer
,是管理锁的抽象类,是独占锁和共享锁的公共父类。
2. 独占锁中的公平锁和非公平锁
公平锁:锁能够采用"公平"的策略分配给线程
非公平锁:锁首先采用"不公平"的策略来分配给线程,如果失败,则再采用"公平"的策略来分配锁。
所以,公平锁/非公平锁代表的是一种分配锁的机制、策略
3. 公平/非公平锁 获取机制
这里以ReentrantLock类来简单地分析一下这两种获取锁策略的实现原理:
首先,类ReentrantLock
实现接口Lock
,其内部有一个final
类型的Sync
抽象类。
private final Sync sync;
该类继承自AbstractQueuedSynchronizer
抽象类
abstract static class Sync extends AbstractQueuedSynchronizer
个人理解,该类AbstractQueuedSynchronizer
的就是一个基于FIFO队列而实现的同步器,或者说是独占锁机制的内部实现。
然后还是在ReentrantLock类内部,有两个内部类:NonfairSync
和FairSync
static final class NonfairSync extends Sync
static final class FairSync extends Sync
从这两个内部静态类的名字中也可以猜到,他们的作用就代表着公平锁/非公平锁的实现机制。
那么接下来就简单分析一下从获取到释放锁的整个过程。
首先先看一下ReentrantLock的构造方法:
public ReentrantLock() {
sync = new NonfairSync();
}
ReentrantLock默认构造方法初始化一个非公平锁NonfairSync
,采用非公平锁机制
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
当然也可以传入boolean
来选择获取锁的机制。
ReentrantLock类初始化完成之后,首先调用lock
方法
public void lock() {
sync.lock();
}
这个时候会根据sync的具体类型来调用不同的lock方法。
** 假如为公平锁FairSync
,那么内部实现为 **
final void lock() {
acquire(1);
}
接下来再看acquire()
方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
该acquire方法是在基类AbstractQueuedSynchronizer
实现的。在该方法中,再调用一个tryAcquire来尝试获取锁:
/**
* 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;
}
调用方法getState()
获取当前锁的占用情况,如果c=0
则说明当前锁没有线程占用,那么调用方法hasQueuedPredecessors
来判断在AbstractQueuedSynchronizer
中维护的FIFO队列是否还有线程,具体实现如下:
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
如果在该队列中还有Node结点(即还有等待的线程),那么就返回true,否则返回false。
- 如果返回true,那么调用的方法
tryAcquire
也就返回false,表示此次获取锁失败。接下来就执行方法addWaiter
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
该方法就是在FIFO队列的尾部新增一个Node结点,进而进行长路漫漫地排队等待。其实该结点就代表了这个线程。其中用到了CAS原子函数compareAndSetTail
来将新增的Node设置为tail
执行完addWaiter
方法之后,紧接着就执行方法acquireQueued
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
该方法就是再一次去获取锁,只不过这一次是尝试给当前Node的上一个Node获取到锁,如果获取成功,则将当前Node设置为Head,否则继续阻塞等待。
至此回想一下,对于公平锁来说,整个获取过程大致为:
- 外部程序调用公平锁的
acquire(1)
方法来获取锁 - 首先第一次调用
tryAcquire
来尝试获取锁,其内部实现原理是通过查看FIFO队列是否还有线程等待来判断能够获取到锁 - 如果第一次尝试失败,则调用
addWaiter
方法来将当前线程作为一个Node加入都FIFO队列的尾端。 - 加入到尾端之后,再一次调用
acquireQueued
方法来查看尾端的上一个Node结点是否是首部并且能否获取到锁,如果可以,则该尾部节点升为头部节点,反之阻塞等待。
** 假如为非公平锁NonFairSync
,那么内部实现为 **
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
与上边说的公平锁一对比就很容易发现,这里多了一个CAS函数compareAndSetState
,它是一个原子操作,作用是比较并设置当前锁的状态。若锁的状态值为0,则设置锁的状态值为1。如果操作成功,则调用setExclusiveOwnerThread
方法来让自己获取到锁。其实这两步操作就体现了非公平锁的获取机制
如果没能提前自己抢占到锁,那么就调用acquire(1)
方法来获取了。接下来调用非公平锁的tryAcquire
方法来尝试获取
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;
}
首先还是查看当前锁的state
多少,如果为0,则再次调用CAS原子操作来抢占获取锁。如果该锁的state不为0, 则判断当前锁是不是自己持有的,如果是,则再次获取,并将state加1,否则返回false
接下来的过程就和公平锁的一样了,如果没有获取到锁,则加入到FIFO队列,然后判断上一个结点等等操作。
4. 独占锁锁和synchronized的区别
synchronized:在很多线程同时竞争一个资源的时候,即在资源竞争激烈的情况下,性能会很低。如果线程较少,则性能还可以。
独占锁:无论资源竞争是否激烈,性能都趋于平稳。其中的tryLock方法为非阻塞方法。
以上就是我对于JUC独占锁的一些学习和总结,但是需要承认的是,里面还有许多细节之处没有讲清楚,其实也是我没有理解。好吧,先掌握住大体的框架,然后最弄懂细节之处。记住,不要让一些繁琐的细节影响了你对整体的把握!
网友评论