当前位置：首页 > news >正文

JUCJUCJUC

news 2026/5/11 16:09:23

内容回顾

1、Lock锁

ReentrantLock

可重入性
公平锁和非公平锁
限时等待
ReentrantLock和synchronized区别

读写锁

读锁共享锁，写锁独占锁
锁降级

2、线程间通信

虚假唤醒

3、并发容器类

ArrayList

-- Vector

-- Collections里面方法

-- CopyOnWrite

今天内容

1、并发容器类

HashSet

//Collections Set<String> set = Collections.synchronizedSet(new HashSet<>());  //CopyOnWrite Set<String> set1 = new CopyOnWriteArraySet<>();

HashMap

HashMap底层结构：数组+链表+树
解决线程安全问题：

//Collections Map<String, String> map = Collections.synchronizedMap(new HashMap<>());  //juc里面对象解决 Map<String, String> map1 = new ConcurrentHashMap<>();

ConcurrentHashMap底层原理（重点）

ConcurrentHashMap底层使用分段锁+CAS
在jdk1.8之前，把数组按照固定大小划分为多个数据段segment，操作数据时候，对数据所在数据段segment进行加锁，底层使用ReentrantLock实现加锁和解锁的
在jdk1.8开始，取消了segment概念，操作数据时候，对数据所在节点进行加锁（数组元素加锁）
CAS: 乐观锁（后面讲）

2、JUC三个常见工具类

三个工具类底层使用AQS（后面讲到）

CountDownLatch（减少计数）

实现倒计时效果
比如发射火箭，10s倒计时，倒计时变成0，火箭发射了

new CountDownLatch(int count) //实例化一个倒计数器，count指定初始计数 countDown() // 每调用一次，计数减一 await() //等待，当计数减到0时，阻塞线程（可以是一个，也可以是多个）并行执行

public class CountDownLatchDemo {  public static void main(String[] args) throws InterruptedException { //创建CountDownLatch对象，设置倒计时初始值 CountDownLatch countDownLatch = new CountDownLatch(6);  //创建6个线程，模拟6个同学 for (int i = 1; i <=6; i++) { new Thread(()->{  System.out.println(Thread.currentThread().getName()+"，开始学习"); try { TimeUnit.SECONDS.sleep(new Random().nextInt(10)); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(Thread.currentThread().getName()+"，结束学习");  //倒计时初始值-1 countDownLatch.countDown(); },"同学"+i).start(); }  //类似拦截的方法 countDownLatch.await();  System.out.println("同学都离开了，值班同学锁门"); } }

CyclicBarrier（循环栅栏）

正计时，多个线程相互等待达到某个共同点之后再一起继续执行
比如：七龙珠

package com.atguigu.juc.util;  import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier;  public class CyclicBarrierDemo {  public static void main(String[] args) throws Exception { //创建CyclicBarrier对象，设置屏障点，达到屏障点之后执行逻辑 CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> { System.out.println("集齐了7颗龙珠，召唤神龙!!!!"); }); //创建7个线程 for (int i = 1; i <=7; i++) {  new Thread(()->{  try { System.out.println(Thread.currentThread().getName()+ "星龙珠集齐了");  cyclicBarrier.await(); } catch (Exception e) { throw new RuntimeException(e); } },String.valueOf(i)).start(); } } }

Semaphore（信号量）

可以控制同时访问的线程个数（限流）
停车场固定3个车位

public Semaphore(int permits) // 构造方法，permits指资源数目（信号量） public void acquire() throws InterruptedException // 占用资源， public void release() // （释放）

package com.atguigu.juc.util;  import java.util.Random; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit;  public class SemaphoreDemo {  public static void main(String[] args) { //创建Semaphore对象，设置资源数量 Semaphore semaphore = new Semaphore(3);  //创建多个线程 for (int i = 1; i <=6; i++) { new Thread(()->{  try { //占用资源 semaphore.acquire();  System.out.println(Thread.currentThread().getName()+"，进入了停车场"); TimeUnit.SECONDS.sleep(new Random().nextInt(5)); System.out.println(Thread.currentThread().getName()+"，驶出停车场");  //释放资源 semaphore.release(); } catch (Exception e) { throw new RuntimeException(e); } },String.valueOf(i)).start(); } } }

3、Callable接口

使用Callable不能直接替换Runnable接口，因为Thread类里面不支持Callable类型，在Thread里面只能传递Runnable类型

package com.atguigu.juc.callable;  import java.util.concurrent.Callable; import java.util.concurrent.FutureTask;  //runnable class Thread1 implements Runnable {  @Override public void run() { System.out.println(Thread.currentThread().getName()); } }  //callable class Thread2 implements Callable<Integer> {  @Override public Integer call() throws Exception { return 1024; } }  public class CallableDemo {  public static void main(String[] args) { //callable，不能创建线程的 //new Thread(new Thread2(),"atguigu02").start();  ////runnable new Thread(new Thread1(),"atguigu01").start(); } }

想办法Runnable 和 Callable建立关系
因为Runnable 和 Callable没有直接关系，找到中间对象建立关系，中间对象意思是和Runnable有关系，和Callable也有关系
使用FutureTask建立Runnable 和 Callable的关系
FutureTask是java.util.concurrent里面类

-- FutrueTask间接实现了Runnable接口，FutrueTask就是Runnable接口实现类

-- FutureTask构造方法参数是Callable类型

package com.atguigu.juc.callable; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; //callable class Thread2 implements Callable<Integer> { @Override public Integer call() throws Exception { System.out.println(Thread.currentThread().getName()); return 1024; } } public class CallableDemo { public static void main(String[] args) { //callable //new Thread(new Thread2(),"atguigu02").start(); //1 创建FutureTask对象，对象构造传递callable类型对象 FutureTask futureTask = new FutureTask(new Thread2()); //2 使用Thread类创建线程 //futureTask是runnable实现类 new Thread(futureTask,"abcd").start(); //get方法获取结果 System.out.println(futureTask.get()); } }

FutureTask特点

特点一：异步计算（表示一个可取消的异步计算任务）

类似于之前说的并行，多个任务一起执行，最终汇总

特点二：获取计算结果

调用FutureTask里面的get方法获取到结果

//get方法获取结果 System.out.println(futureTask.get());

相同任务只会计算一次，后面复用之前结果

特点三：判断任务是否执行完成

//返回结果true任务执行完成，如果false任务执行中 boolean isDone = futureTask.isDone();

callable接口与runnable接口区别

相同点：都是接口，都可以编写多线程程序，都采用Thread.start()启动线程

不同点：

具体方法不同：runnable方法是run方法，callable方法是call方法
Runnable的run方法没有返回值；Callable的call可以返回执行结果，是个泛型
Callable接口的call()方法允许throws异常；Runnable的run()方法异常只能在内部消化，不能往上继续throws

4、阻塞队列（BlockingQueue）

队列特点先进先出，队列有两个操作入队（向队列放元素）和出队（从队列取出元素）
阻塞队列是一种特殊队列，简单理解：入队和出队在特定情况下暂停（阻塞）

被阻塞的情况主要有如下两种：

当队列满了的时候，依然进行入队列操作
当队列空了的时候，依然进行出队列操作

在juc工具类有接口BlockingQueue，方便实现阻塞队列效果，一边向队列里面放元素，一边从队列取出元素

package com.atguigu.juc.queue; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.TimeUnit; public class BlockingQueueDemo { public static void main(String[] args) throws InterruptedException { //创建有界阻塞队列 BlockingQueue<String> queue = new ArrayBlockingQueue<>(3); // 第一组方法：add remove //如果队列满了，继续添加元素抛出异常 //如果队列为空，继续从队列取出元素抛出异常 // System.out.println(queue.add("a")); //入队,正常则返回true // System.out.println(queue.add("b")); // System.out.println(queue.add("c")); //System.out.println(queue.add("d")); //队列已满仍然入队，报异常 // System.out.println(queue.remove()); //出队第一个元素，返回出队元素 // System.out.println(queue.remove()); // System.out.println(queue.remove()); // System.out.println(queue.remove()); //队列已空仍然出队，报异常 //System.out.println(queue.element()); //队列已空仍然获取元素，报异常 // 第二组：offer poll //调用offer方法添加元素，如果队列满了，返回false //调用poll方法从队列取出元素，如果队列为空，返回null // System.out.println(queue.offer("a")); //入队,正常则返回true // System.out.println(queue.offer("b")); // System.out.println(queue.offer("c")); // System.out.println(queue.offer("d")); //队列已满仍然入队, 返回false // System.out.println(queue.poll()); //出队第一个元素，返回出队元素 // System.out.println(queue.poll()); // System.out.println(queue.poll()); // System.out.println(queue.poll()); //队列已空仍然出队，返回null // 第三组：put take //入队时候如果队列满了，进行入队处于阻塞状态 //出队时候，如果队列为空，进行出队处于阻塞状态 // queue.put("a"); //入队 // queue.put("b"); // queue.put("c"); //queue.put("d"); //队列已满仍然入队, 发生阻塞 // System.out.println(queue.take()); //出队第一个元素，返回出队元素 // System.out.println(queue.take()); // System.out.println(queue.take()); // System.out.println(queue.take()); //队列已空仍然出队，发生阻塞*/ // 第四组：offer poll //offer和poll方法设置阻塞时间，超过时间自动结束 System.out.println(queue.offer("a")); //入队,正常则返回true System.out.println(queue.offer("b")); System.out.println(queue.offer("c")); //System.out.println(queue.offer("d", 5, TimeUnit.SECONDS)); //队列已满仍然入队,超时返回false System.out.println(queue.poll()); //出队第一个元素，返回出队元素 System.out.println(queue.poll()); System.out.println(queue.poll()); System.out.println(queue.poll(5, TimeUnit.SECONDS)); //队列已空仍然出队，,超时返回null*/ } }

5、线程池

什么是线程池

之前学习过连接池，德鲁伊连接池，SpringBoot内置连接池等等
连接池优点：预先创建一些连接，把这些连接放到集合里面，每次使用连接可以从集合里面获取连接，使用完这个连接之后放回到集合里面，达到连接复用。一般来讲一个连接池具备可伸缩特性。
现在学习线程池，特点和连接池类似的，目的达到线程复用
创建线程有四种方式，使用线程池是最常用的方式

如何创建线程池

第一种方式使用工具类Executors里面方法进行创建

第二种方式使用ThreadPoolExecutor类自定义代码进行创建（常用）

Executors工具类

直接调用Executors工具类里面静态方法，可以创建不同类型线程池
一池N线程，一池一线程，一池可扩容线程等等
调用execute方法和submit方法从线程池获取线程，执行任务
调用Executors.newFixedThreadPool(3);这个方法时候特点：这个时候只是创建池，在这个池里面目前还没有线程，调用execute方法时候才在池里面创建线程

public class ExecutorsDemo { public static void main(String[] args) { //一池N线程 ExecutorService executorService1 = Executors.newFixedThreadPool(3); // executorService1.submit(() -> { // System.out.println(Thread.currentThread().getName() + ",任务执行..."); // return "atguigu"; // }); //一池一线程 ExecutorService executorService2 = Executors.newSingleThreadExecutor(); //一池可扩容 ExecutorService executorService3 = Executors.newCachedThreadPool(); for (int i = 1; i <=5; i++) { executorService3.execute(()->{ System.out.println(Thread.currentThread().getName()); }); } //executorService3.shutdown(); } }

底层原理

底层使用ThreadPoolExecutor类实现线程池，向这个类里面传递7个参数

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

第一个参数 corePoolSize：核心线程数（常驻线程数、初始线程数）

第二个参数 maximumPoolSize：最大线程数

第三个参数 keepAliveTime：空闲线程存活时间值

第四个参数 TimeUnit：空闲线程存活时间值

第五个参数 workQueue：工作队列（阻塞队列）

第六个参数 ThreadFactory：线程工厂

第七个参数 RejectedExecutionHandler：拒绝策略