第十四章线程工具类

Semaphore

信号量，用来限制能同时访问共享资源的线程上限。

• 信号量Semaphore就是一个计数器，表示当前可用的资源的个数
• 两个核心操作 P申请资源操作 V是释放资源操作

public class SemaphoreDemo {
    
    
    public static void main(String[] args) {
    
    
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <=6; i++) {
    
    
            new Thread(()->{
    
    
                try {
    
    
                    System.out.println(Thread.currentThread().getName()+"\t抢占了车位");
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t离开了车位");
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }finally {
    
    
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}
2	抢占了车位
4	抢占了车位
4	离开了车位
6	抢占了车位
6	离开了车位
3	抢占了车位
3	离开了车位
1	抢占了车位
1	离开了车位
5	抢占了车位
2	离开了车位
5	离开了车位

• acquire(获取)当一个线程调用acquire操作时,它要么通过成功获取信号量(信号量减1),要么一直等下去,直到有线程释放信号量,或超时。

• release(释放)实际上会将信号量的值加1,然后唤醒等待的线程。

• 信号量主要用于两个目的,一个是用于多个共享资源的互斥使用,另一个用于并发线程数的控制。

CountDownLatch(闭锁) 做减法

用来进行线程同步协作，等待所有线程完成倒计时。

• 其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一

public class CountDownLatchDemo {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for (int i = 1; i <=6; i++) {
    
    
            new Thread(()->{
    
    
                System.out.println(Thread.currentThread().getName()+"\t");
                countDownLatch.countDown();
            },i+"").start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t班长关门走人,main线程是班长");

    }
}
1	
6	
5	
4	
3	
2	
main	班长关门走人,main线程是班长

• CountDownLatch主要有两个方法,当一个或多个线程调用await方法时,这些线程会阻塞
• 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)
• 计数器的值变为0时,因await方法阻塞的线程会被唤醒,继续执行

CyclicBarrier做加法

CyclicBarrier的字面意思是可循环(Cyclic) 使用的屏障(barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫做同步点)时被阻塞,知道最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活,线程进入屏障通过CyclicBarrier的await()方法

public class CyclicBarrierDemo {
    
    
    public static void main(String[] args) {
    
    
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        CyclicBarrier cb = new CyclicBarrier(2,()->{
    
    
            System.out.println("任务完成");
        }); // 个数为2时才会继续执行
        for (int i = 0; i < 3; i++) {
    
    
            executorService.submit(()->{
    
    
                System.out.println(Thread.currentThread().getName()+"开始运行" +new Date());
                try {
    
    
                    cb.await(); // 当个数不足时，等待
                } catch (InterruptedException | BrokenBarrierException e) {
    
    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"继续向下运行" +new Date());
            });
            executorService.submit(()->{
    
    
                System.out.println(Thread.currentThread().getName()+"开始运行" +new Date());
                try {
    
    
                    TimeUnit.SECONDS.sleep(2);
                    cb.await(); // 当个数不足时，等待
                } catch (InterruptedException | BrokenBarrierException e) {
    
    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"继续向下运行" +new Date());
            });
        }

    }
}
pool-1-thread-2开始运行Sun Jul 02 13:45:56 CST 2023
pool-1-thread-1开始运行Sun Jul 02 13:45:56 CST 2023
任务完成
pool-1-thread-2继续向下运行Sun Jul 02 13:45:58 CST 2023
pool-1-thread-1继续向下运行Sun Jul 02 13:45:58 CST 2023
pool-1-thread-1开始运行Sun Jul 02 13:45:58 CST 2023
pool-1-thread-2开始运行Sun Jul 02 13:45:58 CST 2023
任务完成
pool-1-thread-2继续向下运行Sun Jul 02 13:46:00 CST 2023
pool-1-thread-1继续向下运行Sun Jul 02 13:46:00 CST 2023
pool-1-thread-2开始运行Sun Jul 02 13:46:00 CST 2023
pool-1-thread-1开始运行Sun Jul 02 13:46:00 CST 2023
任务完成
pool-1-thread-1继续向下运行Sun Jul 02 13:46:02 CST 2023
pool-1-thread-2继续向下运行Sun Jul 02 13:46:02 CST 2023

• 等两个线程都执行了await后，每个执行await的线程会阻塞，等两个线程执行了await，这两个阻塞的线程会继续执行
  • 等两个线程执行了await，就执行输出任务完成
• 注意 CyclicBarrier 与 CountDownLatch 的主要区别在于 CyclicBarrier 是可以重用的 CyclicBarrier 可以被比喻为『人满发车』
• 这里执行任务的线程数要与CyclicBarrier的计数要一致，不然会出错，因为我们这里定义的是任务1和任务2都执行才会向下执行，如果有大于两个线程，可能是执行了两个任务1往下执行

Exchanger

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。它提供一个同步点，在这个同步点两个线程可以交换彼此的数据。这两个线程通过exchange方法交换数据， 如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。因此使用Exchanger的重点是成对的线程使用exchange()方法，当有一对线程达到了同步点，就会进行交换数据。因此该工具类的线程对象是成对的。

• Exchanger类提供了两个方法，String exchange(V x):用于交换，启动交换并等待另一个线程调用exchange；
• String exchange(V x,long timeout,TimeUnit unit)：用于交换，启动交换并等待另一个线程调用exchange，并且设置最大等待时间，当等待时间超过timeout便停止等待。

public class ExchangerDemo {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        final Exchanger exchanger = new Exchanger();
        executor.execute(new Runnable() {
            String data1 = "克拉克森，小拉里南斯";

            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });


        executor.execute(new Runnable() {
            String data1 = "格里芬";

            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });

        executor.execute(new Runnable() {
            String data1 = "哈里斯";

            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });

        executor.execute(new Runnable() {
            String data1 = "以赛亚托马斯，弗莱";

            @Override
            public void run() {
                nbaTrade(data1, exchanger);
            }
        });

        executor.shutdown();
    }

    private static void nbaTrade(String data1, Exchanger exchanger) {
        try {
            System.out.println(Thread.currentThread().getName() + "在交易截止之前把 " + data1 + " 交易出去");
            Thread.sleep((long) (Math.random() * 1000));

            String data2 = (String) exchanger.exchange(data1);
            System.out.println(Thread.currentThread().getName() + "交易得到" + data2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
pool-1-thread-1在交易截止之前把 克拉克森，小拉里南斯 交易出去
pool-1-thread-2在交易截止之前把 格里芬 交易出去
pool-1-thread-3在交易截止之前把 哈里斯 交易出去
pool-1-thread-4在交易截止之前把 以赛亚托马斯，弗莱 交易出去
pool-1-thread-4交易得到格里芬
pool-1-thread-2交易得到以赛亚托马斯，弗莱
pool-1-thread-1交易得到哈里斯
pool-1-thread-3交易得到克拉克森，小拉里南斯