AQS
同步框架,内部维护一个FIFO的双向队列,CLH同步队列。AQS依赖volitail修饰的state标记是否持有锁。乐观锁。维护了一个Node,包含是共享的还是独占的,
state变量,volatile。state等于0或者1代表被加锁或者没被加锁。那个线程把这个公共变量占住,就是持有了锁。
-
请求的共享资源空闲:就将请求资源的线程设成工作线程,将共享资源锁定。
-
如果请求的资源被占用,需要线程阻塞等待以及唤醒机制,借助的是CLH队列实现的,将暂时获取不到资源的线程放到队列里。CLH队列是一个虚拟的双向队列,没有new的动作。是一个一个节点链接形成的。
比喻:求而不得,变成望夫石,盯着资源。已经变成石头了,需要唤醒它。
头线程用完了,将head指针后移。
对于线程的占用方式:
(1)独占:ReenttrantLock,只有一个线程能拿到锁,和syc(不公平的锁)一样。ReenttrantLock有公平锁和不公平锁两种。
公平锁:按照线程在队列中的顺序,先到者先拿到锁。
非公平锁:当线程获取锁时,先通过两次CAS去抢锁,没抢到加到队列中等待唤醒。
比喻:排队买票,非公平锁能不能抢到取决于现在正在交易嘛,如果正在交易就抢不到。如果是交易间隙能抢到。
-
公平锁lock()实现
tryacquire()方法 :获取当前线程,获取state状态。
----如果state是0,检查当前线程是不是队列中的首线程(排队动作)。如果是队列中的头结点,就CAS替换state,设置持有锁的线程为当前线程。
----如果state不是0,判断当前线程是持有锁的线程吗。再次加锁,state+=1;
- 非公平锁lock()实现(吞吐量大,性能好)
上来先cas抢一次锁,抢不到调用acquire()方法。acquire()方法调用tryacquire方法。tryacquire调用nofairtryacquire。先获取当前线程和状态。
如果state是0,将开始抢。抢到就是自己的。如果没抢到就看看当前占用资源的线程是不是本线程,如果是就state+=1。如果不是就没抢到放队列。
默认是非公平锁。
区别:非公平锁在调用 lock 后,首先就会调用 CAS 进行一次抢锁,如果这个时候恰巧锁没有被占用,那么直接就获取到锁返回了。
非公平锁在 CAS 失败后,和公平锁一样都会进入到 tryAcquire 方法,在 tryAcquire 方法中,如果发现锁这个时候被释放了(state == 0),非公平锁会直接 CAS 抢锁,但是公平锁会判断等待队列是否有线程处于等待状态,如果有则不去抢锁,乖乖排到后面。
(2)共享
- Semaphore:控制线程执行的许可,控制线程执行的数量。可以控制流量,消峰。
package com.qxh.bf.aqs;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreExample1 {
// 请求的数量
private static final int threadCount = 550;
public static void main(String[] args) throws InterruptedException {
// 创建一个具有固定线程数量的线程池对象(如果这里线程池的线程数量给太少的话你会发现执行的很慢)
ExecutorService threadPool = Executors.newFixedThreadPool(300);
// 一次只能允许执行的线程数量。
final Semaphore semaphore = new Semaphore(20);
for (int i = 0; i < threadCount; i++) {
final int threadnum = i;
threadPool.execute(() -> {// Lambda 表达式的运用
try {
semaphore.acquire();// 获取一个许可,所以可运行线程数量为20/1=20
test(threadnum);
semaphore.release();// 释放一个许可
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
});
}
threadPool.shutdown();
System.out.println("finish");
}
public static void test(int threadnum) throws InterruptedException {
Thread.sleep(1000);// 模拟请求的耗时操作
System.out.println("threadnum:" + threadnum);
Thread.sleep(1000);// 模拟请求的耗时操作
}
}
- CountDownLatch:允许count个线程阻塞到一个位置,直到所有线程的任务执行完。每使用一次就以CAS的方式对count-1.调用await的方法,如果state不为0就代表没完成 ,一直阻塞。当state为0,释放阻塞的线程。
场景:某个线程等待前n个线程执行完毕。
实现多个线程的开始执行任务的最大并行性,多个线程同时被唤醒,类似赛跑。
package com.qxh.bf.aqs;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchExample1 {
// 请求的数量
private static final int threadCount = 550;
public static void main(String[] args) throws InterruptedException {
// 创建一个具有固定线程数量的线程池对象(如果这里线程池的线程数量给太少的话你会发现执行的很慢)
ExecutorService threadPool = Executors.newFixedThreadPool(300);
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
final int threadnum = i;
threadPool.execute(() -> {// Lambda 表达式的运用
try {
test(threadnum);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
countDownLatch.countDown();// 表示一个请求已经被完成
}
});
}
countDownLatch.await();
threadPool.shutdown();
System.out.println("finish");
}
public static void test(int threadnum) throws InterruptedException {
Thread.sleep(1000);// 模拟请求的耗时操作
System.out.println("threadnum:" + threadnum);
Thread.sleep(1000);// 模拟请求的耗时操作
}
}
//这个代码中一定要注意countdown的次数要大于等于创建线程的个数,否则主线程就会一直等待。
- CyclicBarrier循环栅栏(流量控制 )
全部线程到达被阻塞点,才能继续前进。类似:电影中,金木水火土集齐才能通过关卡。
package com.qxh.bf.aqs;
import java.util.concurrent.*;
public class CyclicBarrierExample2 {
// 请求的数量
private static final int threadCount = 550;
// 需要同步的线程数量
private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
public static void main(String[] args) throws InterruptedException {
// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
for (int i = 0; i < threadCount; i++) {
final int threadNum = i;
Thread.sleep(1000);
threadPool.execute(() -> {
try {
test(threadNum);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
});
}
threadPool.shutdown();
}
public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
System.out.println("threadnum:" + threadnum + "is ready");
try {
/**等待60秒,保证子线程完全执行结束*/
cyclicBarrier.await(60, TimeUnit.SECONDS);
} catch (Exception e) {
System.out.println("-----CyclicBarrierException------");
}
System.out.println("threadnum:" + threadnum + "is finish");
}
}
CountDownLatch是一个计数器,只能用一次。CyclicBarrier可以多次使用。
ReentraLock是java语言级别的锁,sych是jvm虚拟机级别的锁。
(3)模版方法
使用者继承AQS并实现逻辑细节。例如获取独占锁、释放独占锁、获取共享的锁、释放共享的锁。