首页 > 代码库 > java多线程学习--java.util.concurrent
java多线程学习--java.util.concurrent
CountDownLatch，api 文档：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CountDownLatch.html
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.
假设我们要打印1-100，最后再输出“Ok“。1-100的打印顺序不要求统一，只需保证“Ok“是在最后出现即可。
解决方案：我们定义一个CountDownLatch，然后开10个线程分别打印（n-1）*10+1至（n-1）*10+10。主线程中调用await 方法等待所有线程的执行完毕，每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。
package thread;import java.util.concurrent.CountDownLatch;public class TestCountDownLatch { private static final int N = 10; public static void main(String[] args) throws InterruptedException { CountDownLatch doneSignal = new CountDownLatch(N); CountDownLatch startSignal = new CountDownLatch(1);// 开始执行信号 for (int i = 1; i <= N; i++) { new Thread(new Worker(i, doneSignal, startSignal)).start();// 线程启动了 } System.out.println("begin------------"); startSignal.countDown();// 开始执行啦 doneSignal.await();// 等待所有的线程执行完毕 System.out.println("Ok"); } static class Worker implements Runnable { private final CountDownLatch doneSignal; private final CountDownLatch startSignal; private int beginIndex; Worker(int beginIndex, CountDownLatch doneSignal, CountDownLatch startSignal) { this.startSignal = startSignal; this.beginIndex = beginIndex; this.doneSignal = doneSignal; } public void run() { try { startSignal.await(); // 等待开始执行信号的发布 beginIndex = (beginIndex - 1) * 10 + 1; for (int i = beginIndex; i < beginIndex + 10; i++) { System.out.println(i); } } catch (InterruptedException e) { e.printStackTrace(); } finally { doneSignal.countDown(); } } }}
CyclicBarrier，api 文档：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html
A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other. The barrier is called cyclic because it can be re-used after the waiting threads are released.
举一个很简单的例子，今天晚上我们哥们4个去Happy。就互相通知了一下：晚上八点准时到xx酒吧门前集合，不见不散！。有个哥们住的近，早早就到了。有的事务繁忙，刚好踩点到了。无论怎样，先来的都不能独自行动，只能等待所有人
public class TestCyclicBarrier { public static void main(String[] args) { //new 一个线程池 ExecutorService exec = Executors.newCachedThreadPool(); final Random random = new Random(); final CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() { @Override public void run() { System.out.println("大家都到齐了，开始happy去"); } }); for (int i = 0; i < 4; i++) { exec.execute(new Runnable() { @Override public void run() { try { Thread.sleep(random.nextInt(10000)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "到了，其他哥们呢"); try { barrier.await();// 等待其他哥们 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } } }); } exec.shutdown(); }}
Semaphore api：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each
acquire()blocks if necessary until a permit is available, and then takes it. Eachrelease()adds a permit, potentially releasing a blocking acquirer. However, no actual permit objects are used; theSemaphorejust keeps a count of the number available and acts accordingly.
例如：对于某个容器，我们规定，最多只能容纳n个线程同时操作 使用信号量来模拟实现
public class TestSemaphore { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); TestSemaphore t = new TestSemaphore(); final BoundedHashSet<String> set = t.getSet(); for (int i = 0; i < 3; i++) {// 三个线程同时操作add exec.execute(new Runnable() { public void run() { try { set.add(Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } } }); } for (int j = 0; j < 3; j++) {// 三个线程同时操作remove exec.execute(new Runnable() { public void run() { set.remove(Thread.currentThread().getName()); } }); } exec.shutdown(); } public BoundedHashSet<String> getSet() { return new BoundedHashSet<String>(2);// 定义一个边界约束为2的线程 } class BoundedHashSet<T> { private final Set<T> set; private final Semaphore semaphore; public BoundedHashSet(int bound) { this.set = Collections.synchronizedSet(new HashSet<T>());//① this.semaphore = new Semaphore(bound, true); } public void add(T o) throws InterruptedException { semaphore.acquire();// 信号量控制可访问的线程数目 set.add(o); System.out.printf("add:%s%n", o); } public void remove(T o) { if (set.remove(o)) semaphore.release();// 释放掉信号量 System.out.printf("remove:%s%n", o); } }}
解释① ：Collection类中提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题。java中常用的HashSet、ArrayList、HashMap都是线程不安全的，如果多条线程访问他们，而且多于一条的线程试图修改它们，则可能出错。以下方法直接将新建的集合传给了Collections的synchronizedXxx方法，这样就直接获取它们的线程安全实现版本。
Collection c = Collections.synchronizedCollection(new ArrayList()); List l = Collections.synchronizedList(new ArrayList()); Set s = Collections.synchronizedSet(new HashSet()); Map m = Collections.synchronizedMap(new HashMap());
FutureTask api：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/FutureTask.html
A cancellable asynchronous computation. This class provides a base implementation of
Future, with methods to start and cancel a computation, query to see if the computation is complete, and retrieve the result of the computation. The result can only be retrieved when the computation has completed; thegetmethods will block if the computation has not yet completed. Once the computation has completed, the computation cannot be restarted or cancelled (unless the computation is invoked usingrunAndReset()).
应用举例：我们的算法中有一个很耗时的操作，在编程的是，我们希望将它独立成一个模块，调用的时候当做它是立刻返回的，并且可以随时取消的
public class TestFutureTask { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); FutureTask<String> task = new FutureTask<String>( new Callable<String>() {// FutrueTask的构造参数是一个Callable接口 @Override public String call() throws Exception { return Thread.currentThread().getName();// 这里可以是一个异步操作 } }); try { exec.execute(task);// FutureTask实际上也是一个线程 String result = task.get();// 取得异步计算的结果，如果没有返回，就会一直阻塞等待 System.out.printf("get:%s%n", result); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }}
总结：FutureTask其实就是新建了一个线程单独执行，使得线程有一个返回值，方便程序的编写
Exchanger api：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html
package thread;import java.util.ArrayList;import java.util.concurrent.Exchanger;/** * 1. Exchanger用于在2个线程中交换对象。 2. return_object = exchanger.exchange(exch_object) 3. 例子中Producer向ArrayList中缓慢填充随机整数，Consumer从另一个ArrayList中缓慢取出整数并输出。 4. 当Producer的ArrayList填满，并且Consumer的ArrayList为空时，2个线程才交换ArrayList。 * @author Administrator */public class ExchangerTest { private static Exchanger<ArrayList<Integer>> exchanger = null; private static ArrayList<Integer> buffer1 = null; private static ArrayList<Integer> buffer2 = null; public static void main(String[] args) throws Exception { exchanger = new Exchanger<ArrayList<Integer>>(); buffer1 = new ArrayList<Integer>(10); buffer2 = new ArrayList<Integer>(10); Thread pth = new ProducerThread(); Thread cth = new ConsumerThread(); pth.start(); cth.start(); Thread.sleep(60 * 1000); System.out.println("main: interrupting threads."); pth.interrupt(); cth.interrupt(); pth.join(); cth.join(); System.out.println("main: end."); } private static class ProducerThread extends Thread { @Override public void run() { ArrayList<Integer> buff = buffer1; try { while (true) { if (buff.size() >= 10) { // 与consumer交换buffer. System.out.println("producer: exchanging."); buff = exchanger.exchange(buff); buff.clear(); } // 随机产生一个0-100的整数。 int x = (int) (Math.random() * 100); buff.add(x); System.out.println("producer: " + x); // 随机等待0-3秒 。 int t = (int) (Math.random() * 3); Thread.sleep(t * 1000); } } catch (InterruptedException e) { System.out.println("producer: interrupted."); } } } private static class ConsumerThread extends Thread { @Override public void run() { ArrayList<Integer> buff = buffer2; try { while (true) { for (Integer x : buff) { System.out.println("consumer: " + x); // 随机等待0-3秒 。 int t = (int) (Math.random() * 3); Thread.sleep(t * 1000); } // 与producer交换buffer。 System.out.println("consumer: exchanging."); buff = exchanger.exchange(buff); } } catch (InterruptedException e) { System.out.println("consumer: interrupted."); } } }}
在JDK1.5之前，我们关于定时/周期操作都是通过Timer来实现的。但是Timer有以下几种危险[JCIP]
a. Timer是基于绝对时间的。容易受系统时钟的影响。
b. Timer只新建了一个线程来执行所有的TimeTask。所有TimeTask可能会相关影响
c. Timer不会捕获TimerTask的异常，只是简单地停止。这样势必会影响其他TimeTask的执行。
如果你是使用JDK1.5以上版本，建议用ScheduledThreadPoolExecutor代替Timer。它基本上解决了上述问题。它采用相对时间，用线程池来执行TimerTask，会出来TimerTask异常。
import java.util.concurrent.ScheduledThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class TestScheduledThreadPoolExecutor { public static void main(String[] args) { ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1); exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间就触发异常 @Override public void run() { throw new RuntimeException(); } }, 1000, 5000, TimeUnit.MILLISECONDS); exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间打印系统时间，证明两者是互不影响的 @Override public void run() { System.out.println(System.nanoTime()); } }, 1000, 2000, TimeUnit.MILLISECONDS); }}
BlockingQueue API文档：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/BlockingQueue.html
A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
BlockingQueue的经典用途是 生产者-消费者模式
package thread;import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;public class BlockingQueueTest { public static void main(String[] args) { final BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(3); final Random random = new Random(); class Producer implements Runnable { @Override public void run() { while (true) { try { int i = random.nextInt(100); queue.put(i);// 当队列达到容量时候，会自动阻塞的 if (queue.size() == 3) { System.out.println("full"); Thread.sleep(1000); } } catch (InterruptedException e) { e.printStackTrace(); } } } } class Consumer implements Runnable { @Override public void run() { while (true) { try { queue.take();// 当队列为空时，也会自动阻塞 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } new Thread(new Producer()).start(); new Thread(new Consumer()).start(); }}
DelayQueue
在现实生活中，很多DelayQueue的例子。就拿上海的SB会来说明，很多国家地区的开馆时间不同。你很早就来到园区，然后急急忙忙地跑到一些心仪的馆区，发现有些还没开，你吃了闭门羹。
仔细研究DelayQueue，你会发现它其实就是一个PriorityQueue的封装（按照delay时间排序），里面的元素都实现了Delayed接口，相关操作需要判断延时时间是否到了。
在实际应用中，有人拿它来管理跟实际相关的缓存、session等
下面我就通过 “上海SB会的例子来阐述DelayQueue的用法”
package thread;import java.util.Random;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class TestDelayQueue { private class Stadium implements Delayed { long trigger; public Stadium(long i) { trigger = System.currentTimeMillis() + i; } @Override public long getDelay(TimeUnit arg0) { long n = trigger - System.currentTimeMillis(); return n; } @Override public int compareTo(Delayed arg0) { return (int) (this.getDelay(TimeUnit.MILLISECONDS) - arg0 .getDelay(TimeUnit.MILLISECONDS)); } public long getTriggerTime() { return trigger; } } public static void main(String[] args) throws Exception { Random random = new Random(); DelayQueue<Stadium> queue = new DelayQueue<Stadium>(); TestDelayQueue t = new TestDelayQueue(); for (int i = 0; i < 5; i++) { queue.add(t.new Stadium(random.nextInt(30000))); } Thread.sleep(2000); while (true) { Stadium s = queue.take();// 延时时间未到就一直等待 if (s != null) { System.out.println(System.currentTimeMillis() - s.getTriggerTime());// 基本上是等于0 } if (queue.size() == 0) break; } }}
总结：适用于需要延时操作的队列管理
SynchronousQueue API：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/SynchronousQueue.html
这个队列其实是BlockingQueue的一种实现。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。它给我们提供了在线程之间交换单一元素的极轻量级方法
应用举例：我们要在多个线程中传递一个变量。
package thread;import java.util.Arrays;import java.util.List;import java.util.concurrent.BlockingQueue;import java.util.concurrent.SynchronousQueue;public class TestSynchronousQueue { class Producer implements Runnable { private BlockingQueue<String> queue; List<String> objects = Arrays.asList("one", "two", "three"); public Producer(BlockingQueue<String> q) { this.queue = q; } @Override public void run() { try { for (String s : objects) { queue.put(s);// 产生数据放入队列中 System.out.printf("put:%s%n", s); } queue.put("Done");// 已完成的标志 } catch (InterruptedException e) { e.printStackTrace(); } } } class Consumer implements Runnable { private BlockingQueue<String> queue; public Consumer(BlockingQueue<String> q) { this.queue = q; } @Override public void run() { String obj = null; try { while (!((obj = queue.take()).equals("Done"))) { System.out.println(obj);// 从队列中读取对象 Thread.sleep(3000); // 故意sleep，证明Producer是put不进去的 } } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { BlockingQueue<String> q = new SynchronousQueue<String>(); TestSynchronousQueue t = new TestSynchronousQueue(); new Thread(t.new Producer(q)).start(); new Thread(t.new Consumer(q)).start(); }}
总结：SynchronousQueue主要用于单个元素在多线程之间的传递
本文主要参考学习：http://janeky.iteye.com/