JUC(java.util.concurrent)的常见类

落日映苍穹つ 2023-09-27 13:53 108阅读 0赞

![在这里插入图片描述][271f09ef1b4a43fd80dad42f274223fb.gif_pic_center]

#### 文章目录 ####

*  一、JUC常见类
 *   *  Callable 接口
     *  ReentrantLock
     *  Semaphore(信号量)
     *  CountDownLatch

## 一、JUC常见类 ##

concurrent代表了并发，这个包下为我们提供了并发编程(多线程)相关的组件.

### Callable 接口 ###

我们的Callable接口和Runnable是一样的，但也有一些区别:  
Runnable: 用来描述一个任务，描述的任务是没有返回值的。  
Callable: 用来描述一个任务，描述的任务是有返回值的。

所以，我们在一些场景需要线程为我们计算出某个结果的话，就可以使用Callable。

public static void main(String[] args) {
        
            Callable<Integer> callable = new Callable<Integer>() {
        
                @Override
                public Integer call() throws Exception {
        
                    return null;
                }
            };
        }

![在这里插入图片描述][146c3189ac2e4c23914e40e9683c5333.png]  
![在这里插入图片描述][9582a8c748044f68a42d675c043b9092.png]  
当我们直接把callable传入到Thread的构造方法里报错了，没有该构造方法，这里需要套上一层辅助类。  
不能直接放进去，也很简单，因为我们的Callable是带有返回值的，可能有多个线程去执行同一个callable的任务，而且啥时候执行完并不确定，所以我们这里无法获取到返回值，**FutureTask就可以负责这个等待返回值回来的工作。**  
![在这里插入图片描述][cff0c925a948444c886611f3bc550d1b.png]  
然后我们的FutureTask为我们提供了一个get()方法，用来获取任务的返回值。  
![在这里插入图片描述][6a57752883e541b69daca17b546da291.png]  
我们来使用Callable接口实现以下1 + 2 + … + 100

public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            Callable<Integer> callable = new Callable<Integer>() {
        
                @Override
                public Integer call() throws Exception {
        
                    int sum = 0;
                    for (int i = 1; i <= 100; i++) {
        
                        sum += i;
                    }
                    return sum;
                }
            };
            FutureTask<Integer> futureTask = new FutureTask<>(callable);
            Thread t = new Thread(futureTask);
            t.start();
            Integer ret = futureTask.get();
            System.out.println(ret);
        }

![在这里插入图片描述][ae42eea4013342fdb47c5553a95bda6c.png]

### ReentrantLock ###

ReentrantLock是标准库为我们提供的另一种锁，顾名思义。该所也是可重入锁。  
我们的Synchronized也是我们标准库提供的锁，那么它们有什么区别呢?  
Synchronized: 是直接基于代码块进行加锁解锁的。  
ReentrantLock：是使用了lock()方法和unlock()方法进行加锁解锁的。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>lock()</td> 
   <td>加锁，获取不到就死等</td> 
  </tr> 
  <tr> 
   <td>trylock(time 超时时间)</td> 
   <td>加锁，如果一定时间内没有获取到就放弃</td> 
  </tr> 
  <tr> 
   <td>unlock()</td> 
   <td>解锁</td> 
  </tr> 
 </tbody> 
</table>

我们的ReentrantLock在使用起来可能有一些需要注意的事项：

![在这里插入图片描述][e61d14b232234b669eac0a9d55319af7.png]  
![在这里插入图片描述][8e66440d916c49d9af5c5d13d7379846.png]  
我们发现系统这里提示我们lock操作必须搭配try代码块，unlock操作必须搭配finally代码块进行操作。

public static void main(String[] args) {
        
            ReentrantLock reentrantLock = new ReentrantLock();
            try {
        
                reentrantLock.lock();//加锁
            } finally {
        
                reentrantLock.unlock();//解锁
            }
        }

上述是我们ReentrantLock的劣势，当然我们ReentrantLock也是有一些优势的。

1.我们的ReentrantKLock提供了公平锁版本的实现，我们的Synchronized只实现了非公平锁。  
![在这里插入图片描述][488aa7ef4a9c464e9b2aa954f0be34e4.png]  
2. 我们Synchronized尝试加锁，如果锁已经被占有，就进行阻塞等待(死等)，ReentrantLock提供了更灵活的获取锁的方式: trylock()

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>trylock()</td> 
   <td>无参数，能加锁就加，加不上就放弃</td> 
  </tr> 
  <tr> 
   <td>trylock(time)</td> 
   <td>有参数，超过指定时间，加不上锁就放弃</td> 
  </tr> 
 </tbody> 
</table>

3.ReentrantLock提供了一个更方便的等待通知机制，Synchronized搭配的是wait,notify,当我们notify的时候是随即唤醒一个wait状态的线程。ReentrantLock搭配一个Condition类，进行唤醒的时候可以唤醒指定线程。

### Semaphore(信号量) ###

Semaphore(信号量)：信号量本质就是一个计数操作，描述"可用资源的个数"，这里设计两个操作。  
P操作：申请一个可用资源，计数器-1  
V操作：释放一个可用资源，计数器+1

这里我们的信号量可以搭配着停车场来理解：  
我们的停车场的大牌子上就写着，当前剩余车位xx个，当有车进去，就相当于进行了一次P操作，计数器-1，当有车从停车场出来，就相当于进行了一次V操作，计数器+1，当我们的停车场的剩余车位为0时，也就是计数器为0时，如果有车想停车，要么在这里等，要么就去其他停车场。  
我们的Semaphore同样提供了两个方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acquire</td> 
   <td>申请资源</td> 
  </tr> 
  <tr> 
   <td>release</td> 
   <td>释放资源</td> 
  </tr> 
 </tbody> 
</table>

我们在这里设计一个场景，我们图书馆一共有5本《算法导论》，但有10个同学去借

public static void main(String[] args) {
        
            Semaphore semaphore = new Semaphore(5);
            Runnable runnable = new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        System.out.println("我来借书了");
                        semaphore.acquire();
                        System.out.println("我拿到算法导论了!");
                        Thread.sleep(500); //借阅时间
                        System.out.println("我还书了");
                        semaphore.release();
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                }
            };
            for (int i = 0; i < 10; i++) {
        
                Thread t = new Thread(runnable);
                t.start();
            }
        }

![在这里插入图片描述][929ea4d5fafe4098b695a62ae8e96eb5.png]  
我们的锁（可以认为是一个计数器为1的信号量)，锁是信号量的特殊情况，信号量是锁的一般表达。  
实际开发中，锁的出场频率是最高的，但也是有一些特殊的场景会用到信号量。

### CountDownLatch ###

CountDownLatch是一个小组件，用于处理特殊场景下的。  
![在这里插入图片描述][7f094ed1901445e3bddbe6e36e1998b1.png]  
就类似一场跑步比赛，开始时间是明确的，但结束时间是不确定的，只有所有选手冲线了才算结束。  
像这种场景，就引入了CountDownLatch.

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CountDownLatch(人数)</td> 
   <td>在构造的时候，传入一个计数(参赛选手的个数)</td> 
  </tr> 
  <tr> 
   <td>await()</td> 
   <td>等待所有线程执行结束</td> 
  </tr> 
  <tr> 
   <td>countDown()</td> 
   <td>表示选手冲线</td> 
  </tr> 
 </tbody> 
</table>

public static int person;
        public static void main(String[] args) throws InterruptedException {
        
            CountDownLatch latch = new CountDownLatch(5);
            Runnable runnable = new Runnable() {
        
                @Override
                public void run() {
        
                    try {
        
                        Thread.sleep((long) (Math.random() * 1000));
                        System.out.println(person + "号选手冲线了");
                        person++;
                        latch.countDown();
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                }
            };
            for (int i = 0; i < 5; i++) {
        
                Thread t = new Thread(runnable);
                t.start();
            }
            latch.await(); //等5位选手冲线
            System.out.println("比赛结束");
        }

![在这里插入图片描述][34dd6061d4af4fb39466d65c11cdf641.png]  
在我们下载一个大型文件的时候，就可以用到CountDownLatch,比如一款游戏6个G，我们多线程下载，就可以把这个文件切分成许多小文件，多个线程同时下载，我们多线程下载是充分利用了带宽(下载是IO操作，不太涉及CPU)，此处就可以用到CountDownLatch来判断整体是否下载完毕。

[271f09ef1b4a43fd80dad42f274223fb.gif_pic_center]: https://img-blog.csdnimg.cn/271f09ef1b4a43fd80dad42f274223fb.gif#pic_center
[146c3189ac2e4c23914e40e9683c5333.png]: https://img-blog.csdnimg.cn/146c3189ac2e4c23914e40e9683c5333.png
[9582a8c748044f68a42d675c043b9092.png]: https://img-blog.csdnimg.cn/9582a8c748044f68a42d675c043b9092.png
[cff0c925a948444c886611f3bc550d1b.png]: https://img-blog.csdnimg.cn/cff0c925a948444c886611f3bc550d1b.png
[6a57752883e541b69daca17b546da291.png]: https://img-blog.csdnimg.cn/6a57752883e541b69daca17b546da291.png
[ae42eea4013342fdb47c5553a95bda6c.png]: https://img-blog.csdnimg.cn/ae42eea4013342fdb47c5553a95bda6c.png
[e61d14b232234b669eac0a9d55319af7.png]: https://img-blog.csdnimg.cn/e61d14b232234b669eac0a9d55319af7.png
[8e66440d916c49d9af5c5d13d7379846.png]: https://img-blog.csdnimg.cn/8e66440d916c49d9af5c5d13d7379846.png
[488aa7ef4a9c464e9b2aa954f0be34e4.png]: https://img-blog.csdnimg.cn/488aa7ef4a9c464e9b2aa954f0be34e4.png
[929ea4d5fafe4098b695a62ae8e96eb5.png]: https://img-blog.csdnimg.cn/929ea4d5fafe4098b695a62ae8e96eb5.png
[7f094ed1901445e3bddbe6e36e1998b1.png]: https://img-blog.csdnimg.cn/7f094ed1901445e3bddbe6e36e1998b1.png
[34dd6061d4af4fb39466d65c11cdf641.png]: https://img-blog.csdnimg.cn/34dd6061d4af4fb39466d65c11cdf641.png