Java中的线程--线程中的工具

　　这主要想写一下Java中的jdk提供的一些线程中的工具，

一、semaphore信号灯

Semaphore可以维护当前访问自身的线程个数，并提供了同步机制，使用Semaphore可以控制同时访问资源的线程的个数。例如，实现一个文件允许访问的并发数。

Semaphore实现的功能就类似厕所5个坑，假如有10个人要上厕所，那么同时可以有多少人上厕所呢？同时只能有5个人能够占用，当5个人中的任何一个让开后，其中在等待的另外5个中的一个就可以占用了。

单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @className: SemaphoreTest
 * @description: Semaphore信号灯测试实例
 * @author: ssc
 * @date: 2019年6月18日 下午9:01:33
 */
public class SemaphoreTest {

    public static void main(String[] args) {

        ExecutorService services = Executors.newCachedThreadPool();
        Semaphore sp = new Semaphore(3);

        for (int i = 0; i < 10; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        // 查询信号灯的状态 是否可以进入
                        sp.acquire();
                        System.out.println("线程 " + Thread.currentThread().getName() + "进入，当前已有"
                                + (3 - sp.availablePermits()) + " 并发");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("线程 " + Thread.currentThread().getName() + " 即将离开");
                        // 释放信号灯 让别的线程进入
                        sp.release();
                        System.out.println("线程 " + Thread.currentThread().getName() + "已离开，当前已有"
                                + (3 - sp.availablePermits()) + " 并发");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            services.execute(runnable);
        }
    }

}

二、CyclicBarrier循环路障

 字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

使用代码如下：

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @className: CyclicBarrier
 * @description: 线程中的循环路障工具类
 * @author: ssc
 * @date: 2019年6月18日 下午9:58:36
 */
public class CyclicBarrierTest {

    public static void main(String[] args) {
        ExecutorService services = Executors.newCachedThreadPool();
        // 创建 路障实例对象
        CyclicBarrier cb = new CyclicBarrier(3);

        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        
                        Thread.sleep((long) Math.random() * 10000);
                        System.out.println("线程 " + Thread.currentThread().getName() + "即将到达集合地点1，当前已有"
                                + (cb.getNumberWaiting()) + " 到达，正在等候...");
                        // 到此如果没有达到公共屏障点，则该线程处于等待状态，如果达到公共屏障点则所有处于等待的线程都继续往下运行
                        cb.await();

                        Thread.sleep((long) Math.random() * 10000);
                        System.out.println("线程 " + Thread.currentThread().getName() + "即将到达集合地点2，当前已有"
                                + (cb.getNumberWaiting()) + " 到达，正在等候...");
                        cb.await();

                        Thread.sleep((long) Math.random() * 10000);
                        System.out.println("线程 " + Thread.currentThread().getName() + "即将到达集合地点3，当前已有"
                                + (cb.getNumberWaiting()) + " 都到齐了， 继续走啊！");
                        cb.await();

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            services.execute(runnable);
        }
        services.shutdown();
    }

}

 三、CountDownLatch倒计时计时器

CountDownLatch犹如倒计时计时器，调用CountDownLatch对象的countDown方法就将计时器减去1。当计时器到达0时，则所有等待着或者单个等待着开始执行。

可以实现一个人或者是多个人等待其他人通知他，可以实现一个人通知多个人的效果。类似裁判一声口令，运动员同时开始奔跑，或者所有运动员都跑到终点后裁判才可以通知结果。还可以实现一个计划需要多个领导签字后才可以继续向下实施的情况

示例代码如下：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @className: CountDownLatchTest
 * @description: 线程中的计时器类
 * @author: ssc
 * @date: 2019年6月20日 下午9:13:40
 */
public class CountDownLatchTest {

    public static void main(String[] args) {
        ExecutorService services = Executors.newCachedThreadPool();
        // 主线程中的计时器 相当于赛跑中的裁判
        CountDownLatch cdOrder = new CountDownLatch(1);
        // 新建线程的计时器 相当于赛跑中的运动员
        CountDownLatch cdAnswer = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程 " + Thread.currentThread().getName() + "正准备接受命令...");
                        // 等待计时器上技数值 归0 才开始执行 相当于运动员等待裁判的起跑枪声
                        cdOrder.await();
                        System.out.println("线程 " + Thread.currentThread().getName() + "已经接受命令...");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("线程 " + Thread.currentThread().getName() + "等待命令处理结果...");
                        // 计时器上的数值减去1 相当于运动员相继跑到终点 等待裁判宣布最终结果
                        cdAnswer.countDown();
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            services.execute(runnable);
        }
        services.shutdown();
        
        try {
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("线程 " + Thread.currentThread().getName() + "即将发布命令...");
            // 计数器上的 技数的值减去1 这个计数器本身就是 1 就相当于裁判的起跑枪声，只有这个计时器到0，其他线程才开始执行
            cdOrder.countDown();
            System.out.println("线程 " + Thread.currentThread().getName() + "已经发布命令，正在等待结果...");
            // 只有另外三个线程都执行到这里，分别将计时器的数值减去1，下面的代码才执行，相当于裁判等运动员都通过终点，才宣布结果
            cdAnswer.await();
            System.out.println("线程 " + Thread.currentThread().getName() + "已收到所有响应结果...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、Exchanger工具类

用于实现两个人之间的数据交换，每个人在完成一件事物后，想与对方交换数据，第一个拿出数据的人将一直等待第二个人拿出数据来时，才会互相交换

示例代码如下：

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @className: ExchangerTest
 * @description: Exchanger工具类的示例
 * @author: ssc
 * @date: 2019年6月20日 下午10:00:19
 */
public class ExchangerTest {

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

        Exchanger exchanger = new Exchanger();

        services.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String data1 = "abc";
                    System.out.println("线程" + Thread.currentThread().getName() + "正准备把数据" + data1 + "换出去");
                    Thread.sleep((long) (Math.random() * 10000));
                    // 进行数据的交换
                    String data2 = (String) exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName() + "换回的数据是" + data2);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        
        services.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String data1 = "edf";
                    System.out.println("线程" + Thread.currentThread().getName() + "正准备把数据" + data1 + "换出去");
                    Thread.sleep((long) (Math.random() * 10000));
                    // 进行数据的交换
                    String data2 = (String) exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName() + "换回的数据是" + data2);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        services.shutdown();
    }
}