juc包中的大多数同步器实现都是围绕着共同的基础行为,比如等待队 列、条件队列、独占获取、共享获取等,而这些行为的抽象就是基于 AbstractQueuedSynchronizer(简称AQS)实现的,AQS是一个抽象同步框架,可以用来实现一个依赖状态的同步器。
1.1、特性- 阻塞等待队列
- 独占/共享
- 公平/非公平
- 可重入
- 可中断
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
两种资源共享方式
- Exclusive-独占,只有一个线程能执行,如ReentrantLock
- Share-共享,多个线程可以同时执行,如Semaphore/CountDownLatch
- 同步等待队列: 双向链表,主要用于维护获取锁失败时入队的线程
- 条件等待队列: 单向链表,使用nextWait来链接,调用await()的时候会释放锁,然后线程会加入到条件队列,调用 signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中,等待再次获得锁。
- 值为0,初始化状态,表示当前节点在sync队列中,等待着获取锁。
- CANCELLED,值为1,表示当前的线程被取消;
- SIGNAL,值为-1,表示当前节点的后继节点包含的线程需要运行,也就是unpark;
- CONDITION,值为-2,表示当前节点在等待condition,也就是在condition队列中;
- PROPAGATE,值为-3,表示当前场景下后续的acquireShared能够得以执行;
ReentrantLock是一种基于AQS框架的应用实现,是JDK中的一种线程并发访问的同步手段,它的功能类似于synchronized是一种互斥锁,可以保证线程安全。 相对于 synchronized, ReentrantLock具备如下特点:
- 可中断
- 可以设置超时时间
- 可以设置为公平锁
- 支持多个条件变量
- 与 synchronized 一样,都支持可重入
总结几点synchronized和ReentrantLock的区别:
- synchronized是JVM层次的锁实现,ReentrantLock是JDK层次的锁实现;
- synchronized的锁状态是无法在代码中直接判断的,但是ReentrantLock可以通过 ReentrantLock#isLocked判断;
- synchronized是非公平锁,ReentrantLock是可以是公平也可以是非公平的;
- synchronized是不可以被中断的,而ReentrantLock#lockInterruptibly方法是可以被中断的;
- 在发生异常时synchronized会自动释放锁,而ReentrantLock需要开发者在finally 块中显示释放锁;
- ReentrantLock获取锁的形式有多种:如立即返回是否成功的tryLock(),以及等待指定时长的获取,更加灵活;
- synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁(回顾 一下sychronized的唤醒策略),而ReentrantLock对于已经在等待的线程是先来的线程 先获得锁;
ReentrantLock reentrantLock = new ReentrantLock();
for (int i = 0; i < 3; i++) {
new Thread(()-> {
try {
reentrantLock.lock();
System.out.println(Thread.currentThread().getName()+"---获取锁成功-- start exec ");
try {
Thread.sleep(1000000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}finally {
reentrantLock.unlock();
}
},"thread-"+i).start();
}
2.2、源码分析
三、共享锁-Semaphore
Semaphore,俗称信号量,它是操作系统中PV操作的原语在java的实现,它也是基于 AbstractQueuedSynchronizer实现的。 Semaphore的功能非常强大,大小为1的信号量就类似于互斥锁,通过同时只能有一个线程获 取信号量实现。大小为n(n>0)的信号量可以实现限流的功能,它可以实现只能有n个线程同 时获取信号量。
应用场景:可以用于做流量控制,特别是公用资源有限的应用场景
private static ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 50, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>(200));
private static Semaphore semaphore = new Semaphore(3);
public static void main(String[] args) throws InterruptedException {
for (;;) {
Thread.sleep(100);
executor.execute(()->exec());
}
}
public static void exec(){
try {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"---获取锁成功-- start exec ");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}finally {
semaphore.release();
}
}
3.2、源码分析
三、CountDownLatch
CountDownLatch一般用作多线程倒计时计数器,强制它们等待其他一组(CountDownLatch 的初始化决定)任务执行完成。 CountDownLatch的两种使用场景:
- 多个线程等待
- 一个线程等待
模拟并发
CountDownLatch countDownLatch = new CountDownLatch(1);
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(()-> {
try {
System.out.println(Thread.currentThread().getName()+ "-运动员+"+finalI+"等待起跑===================");
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+ "-运动员+"+ finalI +"跑起来===================");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"thread-"+i).start();
}
Thread.sleep(1000L);
System.out.println(Thread.currentThread().getName()+ "=========裁判准备鸣枪");
countDownLatch.countDown();
3.2 示例2
数据汇总-场景应用
static CountDownLatch dataSummaryCountDownLatch = new CountDownLatch(3);
public static void dataSummary() throws InterruptedException {
long currentTimeMillis = System.currentTimeMillis();
Map dataSummaryMap = new HashMap<>();
new Thread(()->{
try {
Thread.sleep(1500L);
} catch (InterruptedException e) {
e.printStackTrace();
}
dataSummaryCountDownLatch.countDown();
System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 名称+");
dataSummaryMap.put("name","张三");
},"thread-1").start();
new Thread(()->{
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
dataSummaryCountDownLatch.countDown();
System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 年龄+");
dataSummaryMap.put("age","18");
},"thread-2").start();
new Thread(()->{
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
dataSummaryCountDownLatch.countDown();
System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 地址+");
dataSummaryMap.put("address","北京");
},"thread-3").start();
dataSummaryCountDownLatch.await();
System.out.println("结束时间=="+(System.currentTimeMillis()-currentTimeMillis)/1000);
}



