JUC详解5

淡淡的烟草味﹌ 2022-12-17 15:53 308阅读 0赞

### JUC详解5 ###

*   *  Callable
     *  常用的辅助类
     *   *  CountDownLatch（减法计数器）
         *  CyclicBarrier（加法计数器）
         *  Semaphore（信号量）

## Callable ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]

*  可以有返回值
 *  可以抛出异常
 *  方法不同：run/call  
    怎么让Callable能够启动线程呢？![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]  
    测试

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /** 1. @Description 2. @ClassName CallableTest 3. @Author cai feifei 4. @date 2020.10.24 12:36 5. @Version */
    public class CallableTest { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            MyThread thread = new MyThread();
            //适配类
            FutureTask<String> futureTask = new FutureTask<>(thread);
            new Thread(futureTask,"A").start();
            //有缓存，所以控制台只打印了一次call方法
            new Thread(futureTask,"B").start();
            //get可能会存在阻塞，解决放到最后，或者使用异步通信处理
            String s = futureTask.get();
            System.out.println(s);
    
        }
    }
    class MyThread implements Callable<String>{ 
    
        @Override
        public String call() throws Exception { 
            System.out.println("执行了call()方法");
            return "1024";
        }
    }

两个细节：

1.  使用callable会有缓存
2.  get方法可能会发生阻塞

## 常用的辅助类 ##

CountDownLatch、CyclicBarrier、Semaphore

### CountDownLatch（减法计数器） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]

public class CountDownLatchTest { 
        public static void main(String[] args) throws InterruptedException { 
            //总数是10，必须执行任务时使用
            CountDownLatch countDownLatch = new CountDownLatch(10);
            for (int i=0;i<10;i++){ 
                new Thread(()->{ 
                    System.out.println(Thread.currentThread().getName()+"出队");
                    //数量减一，每个线程执行完毕
                    countDownLatch.countDown();
                }).start();
            }
            //必须等待计数器归零了，才能继续往下执行
            countDownLatch.await();
            System.out.println("队列清空了");
        }
    }

原理：  
`countDownLatch.countDown()`数量减一  
`countDownLatch.await()`计数器归0时，等待结束，向下继续执行  
每调用一次countDown()，计数器减1，当减为0时，countDownLatch.await()被唤醒，继续向下执行

### CyclicBarrier（加法计数器） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]

public class CyclicBarrierTest { 
        public static void main(String[] args) { 
            CyclicBarrier cyclicBarrier = new CyclicBarrier(10,()->{ 
                System.out.println("集齐10张普通卡片，可兑换高级卡片！");
            });
            for (int i=1;i<=10;i++){ 
                //lamda不能直接获得i，因为开启一个线程相当于另起一个类；所以需要定义一个final变量，作为中间值
                final int temp=i;
                new Thread(()->{ 
                    System.out.println(Thread.currentThread().getName()+"这是第"+temp+"张卡片");
                    try { 
                        cyclicBarrier.await();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) { 
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }

### Semaphore（信号量） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 5]

import java.util.concurrent.Semaphore;
    import java.util.concurrent.TimeUnit;
    
    /** * @Description * @ClassName SemaphoreTest * @Author cai feifei * @date 2020.10.24 14:24 * @Version */
    public class SemaphoreTest { 
        public static void main(String[] args) { 
            //线程数量；停车位；限流
            Semaphore semaphore = new Semaphore(3);
            //6辆车来停车
            for (int i=1;i<=6;i++){ 
                new Thread(()->{ 
                    try { 
                        //acquire得到
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName()+"停入车位");
                        TimeUnit.SECONDS.sleep(2);
                        System.out.println(Thread.currentThread().getName()+"离开车位");
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    } finally { 
                        //release释放
                        semaphore.release();
                    }
                },String.valueOf(i)).start();
            }
        }
    }

`semaphore.acquire()`获得资源；如果资源都被占了，等待，等待被释放为止  
`semaphore.release()`释放资源；将当前信号量释放+1，唤醒等待的线程  
作用：多个共享资源互斥的使用，并发限流，控制最大的线程数

**上一篇：**[JUC详解4——集合相关][JUC_4]

**下一篇：**[JUC详解6——读写锁][JUC_6]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221122/1488a0a0716d4070a9cef5983661131e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221122/b068770297704532b04073d8458fc419.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221122/a3e50ac1a6664b2da95208c041b098a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221122/9c0c8c981e7345d7932d7de62e13f29f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221122/76d6b9639eab48a2a0e4769d1f4e397d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221122/97df2dee240c4cc2aa43a3e37a7c57b8.png
[JUC_4]: https://blog.csdn.net/qq_41510551/article/details/109255245
[JUC_6]: https://blog.csdn.net/qq_41510551/article/details/109259467