并发编程AQS--------ReentrantLock

同步框架AbstractQueuedSynchronizer

Java并发编程核心在于java.concurrent.util包 而juc当中的大多数同步器实现都是围绕着共同的基础行为,比如等待队列、条件队列、独占获取、共享获取等,而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS,AQS定义了一套多线程访问共享资源的同步器框架,是一个依赖状态(state)的同步器。

AQS具备特性 阻塞等待队列、 共享/独占、 公平/非公平、 可重入(同一把锁同一个线程可重复拿)、 允许中断。

一般通过定义内部类Sync继承AQS 将同步器所有调用都映射到Sync对应的方法

 

 state 记录加锁的次数,体现锁的可重入性;访问方式哟有三种   getState()、setState()、compareAndSetState()

exclusiveOwnerThread 体现独占线程的特性,记录的是当前独占的线程。

AQS定义两种资源共享方式 Exclusive-独占,只有一个线程能执行,如ReentrantLock Share-共享,多个线程可以同时执行,如Semaphore/CountDownLatch

Node,阻塞队列的体现:等待队列,条件队列。各种属性定义如下

static final class Node {
/**
* 标记节点未共享模式
* */
static final Node SHARED = new Node();
/**
* 标记节点为独占模式
*/
static final Node EXCLUSIVE = null;

/**
* 在同步队列中等待的线程等待超时或者被中断,需要从同步队列中取消等待
* */
static final int CANCELLED = 1;
/**
* 后继节点的线程处于等待状态,而当前的节点如果释放了同步状态或者被取消,
* 将会通知后继节点,使后继节点的线程得以运行。
*/
static final int SIGNAL = -1;
/**
* 节点在等待队列中,节点的线程等待在Condition上,当其他线程对Condition调用了signal()方法后,
* 该节点会从等待队列中转移到同步队列中,加入到同步状态的获取中
*/
static final int CONDITION = -2;
/**
* 表示下一次共享式同步状态获取将会被无条件地传播下去
*/
static final int PROPAGATE = -3;

/**
* 标记当前节点的信号量状态 (1,0,-1,-2,-3)5种状态
* 使用CAS更改状态,volatile保证线程可见性,高并发场景下,
* 即被一个线程修改后,状态会立马让其他线程可见。
*/
volatile int waitStatus;

/**
* 前驱节点,当前节点加入到同步队列中被设置
*/
volatile Node prev;

/**
* 后继节点
*/
volatile Node next;

/**
* 节点同步状态的线程
*/
volatile Thread thread;

/**
* 等待队列中的后继节点,如果当前节点是共享的,那么这个字段是一个SHARED常量,
* 也就是说节点类型(独占和共享)和等待队列中的后继节点共用同一个字段。
*/
Node nextWaiter;

如果节点存在条件队列中,只能是独占模式不能是共享方式。

等待队列其实是一个双向链表结构,每个节点记录的有前驱节点和后驱节点。

两种队列都是基于Node节点构建的,每个节点的Node都会有信号量,也就是属性waitSate

 

 条件队列其实是单向链表;

 ReentrantLock是一把可重入的,独占的显示锁,构造的时候可以传入一个布尔值来决定是不是公平/非公平锁

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

true为公平锁,false为非公平锁

如何理解公平锁和非公平锁

假如线程A结束后唤醒了线程B,此时新来一个线程C,如果线程C能和线程B抢锁,那么这个是非公平锁,如果新来的线程C只能怪怪去排队,那么就是公平锁。

加锁过程,每加一次锁state都会加1,释放一次锁,state都会减1,exclusiveOwnerThread记录的当前持有锁的线程。

 

 

 分析一下取锁的源码

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {--------表示没有线程占用锁,可以取拿锁
                if (!hasQueuedPredecessors() &&  -------------判断队列里面没有线程在等待才能去抢锁,这就是公平的体现
                    compareAndSetState(0, acquires)) {  -------cas算法原子操作改变state值,state值又被volitale修饰,保证并发下修改state的安全性。
                    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;
        }
    }

 

 线程被阻塞之后会被放在等待队列里面,即我们那个双链表结够,注意我们这个双链表的head的属性thread是null,也就是说head不放任何线程信息,仅仅是做head标记位使用。

 

 

 ReentrantLock加锁的过程

 public final void acquire(int arg) {
        // 尝试获取锁,获取锁失败,addWaiter方法加入到CLH等待队列,Node.EXCLUSIVE表示以独占的方式入队;
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

private Node addWaiter(Node mode) {
// 1. 将当前线程构建成Node类型
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
// 2. 1当前尾节点是否为null?
if (pred != null) {
// 2.2 将当前节点尾插入的方式
node.prev = pred;
// 2.3 CAS将节点插入同步队列的尾部
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}


注意这里的for(;;)循环;
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
//队列为空需要初始化,创建空的头节点
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
//set尾部节点
if (compareAndSetTail(t, node)) {//当前节点置为尾部
t.next = node; //前驱节点的next指针指向当前节点
return t;
}
}
}
}
 

注意AQS里面的线程唤醒不会唤醒所有的等待线程,而回唤醒头节点的next线程(head头节点不放线程),做到顺序唤醒,而object的notify方法和notifyall方法会唤醒所以有的线程。无序。

线程的阻塞和唤醒用的是魔术类Unsafe里面的park()和unpark()方法,底层是调用Pthead_mutex_lock指令库方法。

代码;

 public final void acquire(int arg) {
        // 尝试获取锁,获取锁失败,addWaiter方法加入到CLH等待队列,Node.EXCLUSIVE表示以独占的方式入队;
        // acquireQueued对入队的线程进行阻塞
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
/**
* 已经在队列当中的Thread节点,准备阻塞等待获取锁
*/
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)) {//如果前驱结点是头结点,才tryAcquire,其他结点是没有机会tryAcquire的。
setHead(node);//获取同步状态成功,将当前结点设置为头结点。
p.next = null; // help GC
failed = false;
return interrupted;
}
/**
* 如果前驱节点不是Head,通过shouldParkAfterFailedAcquire判断是否应该阻塞
* 前驱节点信号量为-1,当前线程可以安全被parkAndCheckInterrupt用来阻塞线程
*/
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}

public class LockSupport {
private LockSupport() {} // Cannot be instantiated.

private static void setBlocker(Thread t, Object arg) { //unsafe魔术类阻塞线程。
// Even though volatile, hotspot doesn't need a write barrier here.
UNSAFE.putObject(t, parkBlockerOffset, arg);
}
 

 

posted @ 2020-07-18 17:10  菜鸟的java世界  阅读(79)  评论(0编辑  收藏