CyclicBarrier、CountDownLatch、Callable、FutureTask、thread.join() 、wait()、notify()、Condition
CyclicBarrier使用：
import java.util.Random; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; /** * 三个运动员各自准备，等到三个人都准备好后，再一起跑</br>@see 1:先创建一个公共 CyclicBarrier 对象，设置 同时等待 的线程数，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);</br> 2:这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cyclicBarrier.await(); 即可开始等待别人；</br> 3:当指定的 同时等待 的线程数都调用了 cyclicBarrier.await();时，意味着这些线程都准备完毕好，然后这些线程才 同时继续执行。</br> * */ public class TestCyclicBarrier { public static void main(String[] args) { int runner = 3; final CyclicBarrier cycliBarrier = new CyclicBarrier(runner); final Random random = new Random(); for (char runnerName = 'A'; runnerName <= 'C'; runnerName++) { final String rName = String.valueOf(runnerName); new Thread(new Runnable(){ @Override public void run() { long prepareTime = random.nextInt(10000)+100; System.out.println(rName + " is preparing for time: " + prepareTime); try { Thread.sleep(prepareTime); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(rName + " is prepared, waiting for others"); try { cycliBarrier.await(); // 当前运动员准备完毕，等待别人准备好 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println(rName + " starts running"); // 所有运动员都准备好了，一起开始跑 } }).start(); } } }
输出：
CountDownLatch例子
import java.util.concurrent.CountDownLatch; /** * 四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的@see 1:创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);</br> 2:在 等待线程 里调用 countDownLatch.await() 方法，进入等待状态，直到计数值变成 0；</br> 3:在 其他线程 里，调用 countDownLatch.countDown() 方法，该方法会将计数值减小 1；</br> 4:当 其他线程 的 countDown() 方法把计数值变成 0 时，等待线程 里的 countDownLatch.await() 立即退出，继续执行下面的代码。</br> * */ public class TestCountDownLatch { public static void main(String[] args) { int workerNum = 3; final CountDownLatch countDownlatch = new CountDownLatch(workerNum); new Thread(new Runnable(){ @Override public void run() { System.out.println("D is waiting for other three threads"); try { countDownlatch.await(); System.out.println("D is start work"); Thread.sleep(100); System.out.println("D finsh Work"); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); for (char threadName = 'A'; threadName <= 'C'; threadName++) { final String tName = String.valueOf(threadName); new Thread(new Runnable(){ @Override public void run() { System.out.println(tName + " is working"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(tName + " finished"); countDownlatch.countDown(); } }).start(); } } }
输出：
FutureTask、Callable例子
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * 我们想让子线程去计算从 1 加到 100，并把算出的结果返回到主线程</br> * @see * 如何把子线程的结果回传回来呢？在 Java 里，有一个类是配合 Callable 使用的：FutureTask，不过注意，它获取结果的 get 方法会阻塞主线程。 * */ public class TestCallableAndFutureTask { public static void main(String[] args) { Callable<Integer> callAble = new Callable<Integer>() { @Override public Integer call() throws Exception { System.out.println("Task starts"); Thread.sleep(100); int result = 0; for (int i = 0; i <= 100; i++) { result += i; } System.out.println("Task finished and return result"); return result; } }; FutureTask<Integer> futureTask = new FutureTask<Integer>(callAble); new Thread(futureTask).start(); try { System.out.println("Before futureTask.get()"); System.out.println("Result: " + futureTask.get()); System.out.println("After futureTask.get()"); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
输出：
thread.join() 例子
/** * 实现效果：线程B在线程A完成之后再执行 * thread.join() * */ public class TestThreadJoin { public static void main(String[] args) { demo1(); } private static void demo1() { final Thread A = new Thread(new Runnable(){ @Override public void run() { PrintNumber("A"); } }) ; Thread B = new Thread(new Runnable(){ @Override public void run() { System.out.println("B 开始等待A"); try { A.join(); } catch (InterruptedException e) { e.printStackTrace(); } PrintNumber("B"); } }) ; A.start(); B.start(); } private static void PrintNumber(String ThreadName) { int i = 0; while (i++ < 3) { try { Thread.sleep(100); } catch(InterruptedException e) { e.printStackTrace(); } System.out.println(ThreadName + " print: " + i); } } }
输出：
wait()、notify() 例子：
public class TestWaitAndnotify { public static void main(String[] args) { demo2(); } public static void demo2 () { final Object lock = new Object(); Thread A = new Thread(new Runnable(){ @Override public void run() { System.out.println("INFO: A 等待锁 "); synchronized (lock) { System.out.println("INFO: A 得到了锁 lock"); System.out.println("A1"); try { System.out.println("INFO: A 准备进入等待状态，放弃锁 lock 的控制权 "); lock.wait();//挂起线程A 放弃锁 lock 的控制权 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("INFO: 有人唤醒了 A, A 重新获得锁 lock"); System.out.println("A2"); System.out.println("A3"); } } }); Thread B = new Thread(new Runnable() { @Override public void run() { System.out.println("INFO: B 等待锁 "); synchronized (lock) { System.out.println("INFO: B 得到了锁 lock"); System.out.println("B1"); System.out.println("B2"); System.out.println("B3"); System.out.println("INFO: B 打印完毕，调用 notify 方法 "); lock.notify(); // notify()方法唤醒正在等待lock锁的线程A System.out.println("线程 B do notify method 完毕"); } } }); A.start(); B.start(); } }
输出：
Condition 例子（生产消费）：
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TestCondition { public static void main(String[] args) { final BoundedBuffer b = new BoundedBuffer(); new Thread(new Runnable() { // 写线程 public void run() { int i = 1; while (true) { try { b.put(i++); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(new Runnable() { // 读线程 public void run() { while (true) { try { b.take(); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); } } class BoundedBuffer{ final Lock lock = new ReentrantLock(); // 锁对象 final Condition notFull = lock.newCondition(); // 写线程条件 final Condition notEmpty = lock.newCondition(); // 读线程条件 final Integer[] items = new Integer[10]; // 缓存队列 int putptr; // 写索引 int takeptr; // 读索引 int count; // 队列中存在的数据个数 public void put(Integer x) throws InterruptedException { lock.lock(); try { while(count == items.length) { // 如果队列满了 notFull.await(); // 阻塞写线程 } items[putptr] = x; // 赋值 System.out.println("写入：" + x); if(++putptr == items.length) { // 如果写索引写到队列的最后一个位置了，那么置为0 putptr = 0; } ++count; // 个数++ notEmpty.signal(); // 唤醒读线程 } finally { lock.unlock(); } } public Integer take() throws InterruptedException { lock.lock(); try { while(count == 0) { // 如果队列为空 notEmpty.await(); // 阻塞读线程 } Integer x = items[takeptr]; // 取值 System.out.println("读取：" + x); if(++takeptr == items.length) { // 如果读索引读到队列的最后一个位置了，那么置为0 takeptr = 0; } --count; // 个数-- notFull.signal(); return x; } finally { lock.unlock(); } } }
输出：
.......
