03并发编程_工具类

Semaphore（信号量）

信号量模型还是很简单的，可以简单概括为：一个计数器，一个等待队列，三个方法。在信号量模型里，计数器和等待队列对外是透明的，所以只能通过信号量模型提供的三个方法来访问它们，这三个方法分别是：init()、down() 和 up()。你可以结合下图来形象化地理解。

这三个方法详细的语义具体如下所示。

init()：设置计数器的初始值

down()：计数器的值减 1；如果此时计数器的值小于 0，则当前线程将被阻塞，否则当前线程可以继续执行。

up()：计数器的值加 1；如果此时计数器的值小于或者等于 0，则唤醒等待队列中的一个线程，并将其从等待队列中移除。

这里提到的 init()、down() 和 up() 三个方法都是原子性的，并且这个原子性是由信号量模型的实现方保证的。在 Java SDK 里面，信号量模型是由 java.util.concurrent.Semaphore 实现的，Semaphore 这个类能够保证这三个方法都是原子操作。

如何使用信号量

static int count;
//初始化信号量
static final Semaphore s 
    = new Semaphore(1);
//用信号量保证互斥    
static void addOne() {
  s.acquire();
  try {
    count+=1;
  } finally {
    s.release();
  }
}

实现一个有5个停车位的停车场跑，有10辆车申请进入停车场实例代码，Semaphore定义一个5个车位的停车场，每个线程就是一辆车

public class CarDemoSemaphore {

    public static void main(String[] args) {
        //创建Semaphore
        Semaphore sp = new Semaphore(5);//停车场
        Thread[] cars = new Thread[10]; //车辆
        for (int i = 0; i < cars.length; i++) {
            cars[i] = new Thread(()->{
                try {
                    sp.acquire();//申请进入停车场
                    System.out.println(Thread.currentThread().getName()+"可以进停车场");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //随机停留时间
                int val = new Random().nextInt(10);
                try {
                    TimeUnit.SECONDS.sleep(val);
                    System.out.println(Thread.currentThread().getName()+"停留了"+val+"秒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //车辆出停车场
                sp.release();
                System.out.println(Thread.currentThread().getName()+"离开停车场");
            },cars+"["+i+"]");
            cars[i].start();
        }
    }
}

CountDownLatch

作用：是一个线程等待其他的线程完成工作后再执行，加强版的join

public class FightQueryDemo{

    private static List<String> company = Arrays.asList("东方航空","南方航空","海南航空");
    private static List<String> figthList = new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        String origin = "BJ";
        String dest = "SH";
        Thread[] threads = new Thread[company.size()];
        CountDownLatch latch = new CountDownLatch(company.size());
        for (int i = 0; i < threads.length; i++) {
            String name = company.get(i);
            threads[i] = new Thread(()->{
                System.out.printf("%s 查询从%s 到 %s 的机票\n",name,origin,dest);
                //随机产生票数
                int val = new Random().nextInt(10);
                try {
                    TimeUnit.SECONDS.sleep(val);
                    figthList.add(name+"--"+val);
                    System.out.printf("%s公司查询成功\n",name);
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads[i].start();
        }
        latch.await();
        System.out.println("====查询结果如下====");
        figthList.forEach(System.out::println);
    }
}

CyclicBarrier的作用

让一组线程到达某个屏障，被阻塞，一直到组内最后到达屏障时，屏障开放，所有被阻塞的线程继续执行

public class RaceDemoCyclicBarrier {

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(8);
        Thread[] plays = new Thread[8];
        for (int i = 0; i < plays.length ; i++) {
            plays[i] = new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                    System.out.println(Thread.currentThread().getName() + "准备好了");
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("选手"+ Thread.currentThread().getName()+"起跑");
            },"paly["+i+"]");
            plays[i].start();
        }
    }
}

CountDownLatch与CyclicBarrier区别

CountDownLatch 主要用来解决一个线程等待多个线程的场景，可以类比旅游团团长要等待所有的游客到齐才能去下一个景点；CyclicBarrier 是一组线程之间互相等待，更像是几个驴友之间不离不弃。

 CountDownLatch 的计数器是不能循环利用的，也就是说一旦计数器减到 0，再有线程调用 await()，该线程会直接通过。 CyclicBarrier 的计数器是可以循环利用的，而且具备自动重置的功能，一旦计数器减到 0 会自动重置到你设置的初始值。除此之外，CyclicBarrier 还可以设置回调函数，可以说是功能丰富