多线程与高并发（四）：JUC中的多线程辅助类

一、CountDownLatch

CountDownLatch是门栓的意思，门栓上维护着一个计数器，每调用一次countDown，计数器就减1，当计数器减到0时，门栓打开，被await的线程开始执行。

public static void main(String[] args) throws InterruptedException {
	// 初始化门栓和计数器
	CountDownLatch countDownLatch = new CountDownLatch(100);

	for (int i = 0; i < 100; i++) {
		new Thread(() -> {
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " finished!");
			// 计数器减1
			countDownLatch.countDown();
		}, "t" + i).start();
	}
	// 开始等待
	countDownLatch.await();
	new Thread(() -> System.out.println("last finished!")).start();
}

注：

可通过 await(long timeout, TimeUnit unit)设置等待时间，如果该方法返回false，说明在计时器减到0之前就因为超时结束等待。

CountDownLatch底层实现为AQS

 

二、CyclicBarrier

CyclicBarrier是循环栅栏的意思，CyclicBarrier中也有一个计数器，每当线程调用await时，调用await的线程开始等待，且计数器的值+1，当计数器达到设定的阈值时，所有等待的线程被唤醒，开始继续执行，计数器的值归0，开始重新计数。之后调用await方法的线程又开始等待，周而复始。

public static void main(String[] args) {
    // 初始化栅栏
	CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> System.out.println("one circle"));

	for (int i = 0; i < 20; i++) {
		new Thread(() -> {
			try {
				TimeUnit.SECONDS.sleep(1);
				// 线程等待
				cyclicBarrier.await();
			} catch (InterruptedException | BrokenBarrierException e) {
				e.printStackTrace();
			}
		}).start();
	}
}

注：

初始化栅栏时，若在参数中传入一个Runnable，则会在栅栏打开时立即运行此线程。

可通过 await(long timeout, TimeUnit unit)设置等待时间，如果该方法返回false，说明在计时器减到0之前就因为超时结束等待。

CyclicBarrier底层实现为AQS

 

三、Phaser

Phaser为阶段，类似于CyclicBarrier，不过它不是循环的，而是分为多个阶段，每一个阶段都有一个栅栏，栅栏上存在一个计数器，当线程调用arriveAndAwaitAdvance会开始等待并将计数器+1，当计数器达到指定阈值时，会回调onAdvance方法，并唤醒所有等待的线程，让线程继续往下执行。

public class PhaserTest {
    static class StepPhaser extends Phaser {
        @Override
        public boolean onAdvance(int phase, int registeredParties) {
            switch (phase) {
                case 0:
                    System.out.println("all step zero finished " + registeredParties);
                    return false;
                case 1:
                    System.out.println("all step one finished " + registeredParties);
                    return false;
                case 2:
                    System.out.println("all step two finished " + registeredParties);
                    return false;
                case 3:
                    System.out.println("all step three finished " + registeredParties);
                    return true;
                default:
                    return true;
            }
        }
    }

    static class Step implements Runnable {
        private String name;
        private StepPhaser phaser;

        public Step(String name, StepPhaser phaser) {
            this.name = name;
            this.phaser = phaser;
        }

        private void stepZero() {
            System.out.println(Thread.currentThread().getName() + " step zero");
            phaser.arriveAndAwaitAdvance();
        }

        private void stepOne() {
            System.out.println(Thread.currentThread().getName() + " step one");
            phaser.arriveAndAwaitAdvance();
        }

        private void stepTwo() {
            System.out.println(Thread.currentThread().getName() + " step two");
            phaser.arriveAndAwaitAdvance();
        }

        private void stepThree() {
            if (this.name.equals("thread1") || this.name.equals("thread2")) {
                System.out.println(Thread.currentThread().getName() + " step three");
                phaser.arriveAndAwaitAdvance();
            } else {
                phaser.arriveAndDeregister();
            }
        }

        @Override
        public void run() {
            stepZero();
            stepOne();
            stepTwo();
            stepThree();
        }
    }

    public static void main(String[] args) {
        StepPhaser phaser = new StepPhaser();
        // 给每个栅栏的计数器阈值增加10，phaser.register()表示给阈值增加1
        phaser.bulkRegister(10);
        for (int i = 0; i < 10; i++) {
            new Thread(new Step("thread" + i, phaser)).start();
        }
    }
}

注：

onAdvance方法的两个参数分别为，目前线程处于哪个阶段，以及阈值大小为多少。

onAdvance方法返回fasle时，说明阶段还未结束，后续阶段还会继续使线程等待，返回true时，则结束phaser，后续的阶段不会再让线程等待。

arriveAndAwaitAdvance方法可以使线程开始等待，当等待的线程达到阈值时，线程会被换线继续执行。

arriveAndDeregister方法可以使阈值-1，线程调用此方法后不会等待，而是继续执行。

Phaser类需要被继承，重写onAdvance方法，否则默认的阶段只有0个。

可以使用bulkRegister方法使阈值增加指定大小，也可以使用register方法使阈值+1。

Phaser底层实现为AQS

 

四、Semaphore

Semaphore信号量，可以将线程设置为最多多少个同时执行，其余的线程阻塞。

public static void main(String[] args) {
	Semaphore semaphore = new Semaphore(2);

	for (int i = 0; i < 10; i++) {
		new Thread(() -> {
			try {
                // 争抢
				semaphore.acquire();
				System.out.println(Thread.currentThread().getName() + " start");
				TimeUnit.SECONDS.sleep(1);
				System.out.println(Thread.currentThread().getName() + " finish");
                // 释放
				semaphore.release();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				semaphore.release();
			}
		}).start();
	}
}

注：

acquire（获取）：当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量-1），要么一直等下去，直到有线程释放信号量，或超时。

release（释放）：将信号量+1，然后唤醒等待的线程。

使用目的：① 用于多个共享资源的互斥使用；② 用于并发线程数的控制。

Semaphore底层实现为AQS

 

五、Exchanger

用于两个线程之间的数据交换，当一个线程执行交换后，会将数据放入交换器，并阻塞等待另一个线程将数据放入交换器。Exchanger只能用于两个线程间的数据交换。

public class ExchangerTest {
    static Exchanger<String> exchanger = new Exchanger<>();
    public static void main(String[] args) {
        new Thread(() -> {
            String s = "T1";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);
        }, "t1").start();
        new Thread(() -> {
            String s = "T2";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);
        }, "t2").start();
    }
}

 

六、LockSupport

LockSupport提供了对线程进行阻塞和唤醒的方法，类似于wait和notify，但它会比wait、notify稍微灵活一些。

1、wait、notify的一些不足：

① 因为wait()方法需要释放锁，所以必须在synchronized中使用，否则会抛出异常 IllegalMonitorStateException

② notify()方法也必须在synchronized中使用

③ synchronized()、wait()、notify()对象必须一致，一个synchronized()代码块中只能有一个线程调 用wait()或notify()

2、LockSupport的使用：

① LockSupport.park：使当前线程进入阻塞状态

② LockSupport.unpark(Thread thread)：使指定线程从阻塞状态中唤醒

3、LockSupport实现原理：

park()和unpark()方法的实现是由Unsafe类提供的，它主要通过一个变量作为一个标识，变量值在0，1之间来回切换，调用unpark方法时，变量会被置为1，调用park时，变量会被置为0。当变量为1时，说明线程已经获取执行过了unpark方法，遇到park不会被阻塞。

4、注：

1、LockSupport不需要synchornized加锁就可以实现线程的阻塞和唤醒

2、在线程start后，LockSupport.unpartk()可以先于LockSupport.park()执行，并且线程不会阻塞。

3、unpark必须在线程start之后才有用，之前调用没有任何效果（This operation is not guaranteed to have any effect at all if the given thread has not been started）

4、连续多次调用unpark也只能使得一次park不会被阻塞（由于内置变量只能为0或1，多次调用还是为1）