现在的位置: 首页 > 综合 > 正文

java并发编程-构建块

2012年10月20日 ⁄ 综合 ⁄ 共 8061字 ⁄ 字号 小 中 大 ⁄ 评论关闭

java5引入了很多新的并发容器和工具，极大的简化了并发程序的编写。本文先介绍Collections.synchronizedXXX工厂方法创建的同步容器的不足，再介绍ConcurrentHashMap，CopyOnWriterArrayList，BlockingQueue，CountDownLatch，Semaphore，CyclicBarrier和显示锁类。

 

一、引言

所有的并发问题都来源于如何协调访问并发状态，可变状态越少，并发控制也就越容易容易。没有可变状态的对象永远是现成安全。对有可变状态的对象的并发访问必须进行加锁，对每个方法都加锁并不能保证并发访问一定处于一致的状态。在构建并发程序的时候，可以把并发的控制代理到已有的并发类，比如类库提供的并发容器或工具。

二、同步容器的不足

对Collections.synchronizedXXX工厂方法创建的同步容器，每个方法都是使用该容器的内部锁进行控制的，这会带来一性能问题，因为多个安全的读操作也要等待排它锁。即使每个方法的调用都是线程安全的，但同时调用多个操作室，不一定是线程安全的，比如缺少即添加，相等即修改等炒作，是两步原子操作构成的，和在一起并不是原子的，必须在调用代码里使用容器的锁进行控制。另外在迭代集合的时候，还会由于并发修改而抛出ConcurrentModefiedExceptioin，这往往是调用程序不希望的结果。

三、ConcurrentHashMap，CopyOnWriterArrayList

ConcurrentHashMap使用的内部细粒度的分离锁，这个锁机制允许任意数量的读线程并发访问，提高了吞吐率。在迭代时不会抛出ConcurrentModefiedExceptioin，如果在迭代期间有修改发生，返回的是迭代开始时的状态。另外对缺少即添加，相等即修改等二元操作也有相应的方法支持。ConcurrentHashMap实现了ConcurrentMap提供的几个特殊原子操作：

public V putIfAbsent(K key,  V value)

如果指定键已经不再与某个值相关联，则将它与给定值关联。

public boolean remove(Object key, Object value)

只有目前将键的条目映射到给定值时，才移除该键的条目。

public boolean replace(K key, V oldValue, V newValue)

只有目前将键的条目映射到给定值时，才替换该键的条目。

public V replace(K key, V value)

只有目前将键的条目映射到某一值时，才替换该键的条目。

 

CopyOnWriterArrayList 是ArrayList的一个并发替代品，通常情况下，它提供比较好的并发性，允许多个现在并发的对其进行迭代。每次需要修改时，便会创建并重新发布一个新的容器拷贝，以此来实现可变性。因为底层使用数组实现，如果数组元素较多是，复制多付出的代价较大。

三、BlockingQueue

阻塞队列提供了可以阻塞的put和take方法，以及与之等价的可以指定超时的offer和poll。如果Queue是空的，那么take方法会一直阻塞，直到有元素可用。如果Queue是有线长度的，队列满的时候put方法也会阻塞。BlockingQueue可以很好的支持生产者和消费者模式，生产者往队列里put，消费者从队列里get，两者能够得好很好的同步。BlockingQueue的实现类LinkedBlockingQueue和ArrayBlockingQueue是FIFO队列，PriorityBlockingQueue是一个按优先级排序的队列。使用BlockingQueue构建的一个生产者与消费例子：

消费者：

Java代码  收藏代码
  1. public class Consumer implements Runnable {  
  2.   
  3.     private BlockingQueue<Food> queue;  
  4.     private ExecutorService exec;  
  5.   
  6.     public Consumer(BlockingQueue<Food> queue, ExecutorService exec) {  
  7.         this.queue = queue;  
  8.         this.exec = exec;  
  9.     }  
  10.   
  11.     @Override  
  12.     public void run() {  
  13.         while (!exec.isShutdown()) {  
  14.             try {  
  15.                 Thread.sleep(2000);  
  16.                 Food food = queue.take();  
  17.                 System.out.println("Consumer " + food);  
  18.             } catch (InterruptedException e) {  
  19.                 e.printStackTrace();  
  20.             } catch (RejectedExecutionException e) {  
  21.   
  22.             }  
  23.         }  
  24.     }  
  25. }  

 生产者：

Java代码  收藏代码
  1. public class Producer implements Runnable {  
  2.   
  3.     private BlockingQueue<Food> queue;  
  4.     private ExecutorService exec;  
  5.   
  6.     public Producer(BlockingQueue<Food> queue, ExecutorService exec) {  
  7.         this.queue = queue;  
  8.         this.exec = exec;  
  9.     }  
  10.   
  11.     @Override  
  12.     public void run() {  
  13.         while (!exec.isShutdown()) {  
  14.             Food food = new Food();  
  15.             try {  
  16.                 Thread.sleep(4000);  
  17.                 queue.put(food);  
  18.                 System.out.println("Produce " + food);  
  19.             } catch (InterruptedException e) {  
  20.                 e.printStackTrace();  
  21.             } catch (RejectedExecutionException e) {  
  22.   
  23.             }  
  24.         }  
  25.     }  
  26. }  

 Main：

Java代码  收藏代码
  1. BlockingQueue<Food> queue = new ArrayBlockingQueue<Food>(5);  
  2. ExecutorService exec = Executors.newFixedThreadPool(3);  
  3. Producer p1 = new Producer(queue, exec);  
  4. Producer p2 = new Producer(queue, exec);  
  5.   
  6. Consumer c1 = new Consumer(queue, exec);  
  7.   
  8. exec.execute(p1);  
  9. exec.execute(p2);  
  10. exec.execute(c1);  
  11. try {  
  12.     Thread.sleep(10000);  
  13. } catch (InterruptedException ignored) {  
  14. }  
  15. exec.shutdown();  

 四、CountDownLatch

闭锁（Latch），它可以延迟线程的进度知道线程到达终止状态。一个闭锁工作方式就像一道门，直到闭锁到达终点状态之前，门一直关闭着。终点状态到了之后，所有阻塞的线程都可以通过。CountDownLatch 使用一个计数器作为终点状态，知道计数器的值到达0时，闭锁才会打开。调用await 方法，线程会阻塞知道计数器为0，countDown 方法使计数器减一。

闭锁有两种常见的用法，开始闭锁，结束闭锁。开始闭锁用于等待一个条件到达后所有线程一起执行，结束闭锁可以用来等待所有条件或所有线程结束后再进行后续处理。例子：

Java代码  收藏代码
  1. final CountDownLatch startLatch = new CountDownLatch(1);  
  2. final CountDownLatch endLatch = new CountDownLatch(3);  
  3. Runnable prepare = new Runnable() {  
  4.     @Override  
  5.     public void run() {  
  6.         try {  
  7.             startLatch.await();//等待开始闭锁，线程同时开始执行  
  8.             System.out.println("收拾东西，准备出门");  
  9.             Random rnd = new Random();  
  10.             Thread.sleep(rnd.nextInt(1000));  
  11.         } catch (InterruptedException ignored) {  
  12.         }  
  13.         endLatch.countDown();  
  14.     }  
  15. };  
  16.   
  17. Thread mum = new Thread(prepare);  
  18. Thread dad = new Thread(prepare);  
  19. Thread me = new Thread(prepare);  
  20. mum.start();  
  21. dad.start();  
  22. me.start();  
  23. startLatch.countDown();  
  24. try {  
  25.     endLatch.await();  
  26. } catch (InterruptedException ignored) {  
  27. }  
  28. System.out.println("逛街");  

 五、Semaphore，信号量

使用信号量进行同步和互斥的控制是最经典的并发模型，java中也提高支持。一个Semaphore管理一个有效的许可 集，许可基的数量通过构造函数传入，通过acquire方法申请一个许可，许可数为0则阻塞线程，否则许可数减一，使用release方法释放一个许个，许可数加一。一个技术量为1的Semaphore为二元信号量，相当于一个互斥锁，表示不可重入的锁。一个使用信号量控制并发容器上届的例子：

Java代码  收藏代码
  1. public class BoundedHashSet<T> {  
  2.     private final Set<T> set;  
  3.     private final Semaphore sem;  
  4.   
  5.     public BoundedHashSet(int bound) {  
  6.         set = Collections.synchronizedSet(new HashSet<T>());  
  7.         sem = new Semaphore(bound);  
  8.     }  
  9.   
  10.     public boolean add(T o) throws InterruptedException {  
  11.         sem.acquire();  
  12.         boolean wasAdded = false;  
  13.         try {  
  14.             wasAdded = set.add(o);  
  15.             return wasAdded;  
  16.         } finally {  
  17.             if (!wasAdded)  
  18.                 sem.release();  
  19.         }  
  20.     }  
  21.   
  22.     public boolean remove(Object o) {  
  23.         boolean wasRemoved = set.remove(o);  
  24.         if (wasRemoved)  
  25.             sem.release();  
  26.         return wasRemoved;  
  27.     }  
  28. }  

 六、CyclicBarrier

关卡（Barrier）类似于闭锁，他们都能阻塞一组线程，知道某些事件发生，不同之处在于所有CyclicBarrier等待的是现线程，只有一定数目的线程到达这个点时，才允许同时通过。它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作很有用。

Java代码  收藏代码
  1. public class Main {  
  2.   
  3.     public static CyclicBarrier getCyclicBarrier(int count) {  
  4.         if (count <= 0)  
  5.             return null;  
  6.         final CyclicBarrier cyclicBarrier = new CyclicBarrier(count,  
  7.                 new Runnable() {  
  8.                     public void run() {  
  9.                         try {  
  10.                             Thread.sleep(1000);  
  11.                         } catch (InterruptedException e) {  
  12.                             e.printStackTrace();  
  13.                         }  
  14.                         System.out.println("conditon is arrive and CycleBarrier is running");  
  15.                     }  
  16.                 });  
  17.         return cyclicBarrier;  
  18.     }  
  19.   
  20.     public static Thread getThread(String nameOfThread,  
  21.             final CyclicBarrier cyclicBarrier) {  
  22.         Thread thread = new Thread(nameOfThread) {  
  23.             public void run() {  
  24.                 System.out.println(this.getName() +  
  25. "is begin; and count is "+ (++count));  
  26.                 try {  
  27.                     cyclicBarrier.await();  
  28.                 } catch (InterruptedException e) {  
  29.                     e.printStackTrace();  
  30.                 } catch (BrokenBarrierException e) {  
  31.                     e.printStackTrace();  
  32.                 }  
  33.                 System.out.println(this.getName() + "finished");  
  34.             }  
  35.         };  
  36.         return thread;  
  37.   
  38.     }  
  39.   
  40.     static int count = 0;  
  41.   
  42.     public static void main(String[] args) {  
  43.         /** define a cyclicBarrier and number of barrier is 2. */  
  44.         CyclicBarrier cyclicBarrier = getCyclicBarrier(2);  
  45.         Thread threadOne = getThread("threadOne", cyclicBarrier);  
  46.         threadOne.start();  
  47.         Thread threadTwo = getThread("threadTwo", cyclicBarrier);  
  48.         threadTwo.start();  
  49.     }  
  50. }  

 该例子中CyclicBarrier等待两个线程到达后输出conditon is arrive and CycleBarrier is running，两个线程都从await中返回。

七、显式锁

 

在java 5之前，用于调节共享对象访问的机制只有synchronized和volatile。java 5提供了新的选择：ReentrantLock。ReentrantLock能够提供更多的高级特性，比如轮询和可定时的加锁，可中断的加锁。以及一个支持读锁和写锁的ReentrantReadWriteLock。使用ReentrantLock必须手动使用lock或其他操作加锁，在finally块中unlock。

ReentrantLock：一个可重入的互斥锁Lock，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 使用ReentrantLock构建的同步Map：

Java代码  收藏代码
  1. public class LockedMap<K, V> {  
  2.     private Map<K, V> map;  
  3.     private Lock lock = new ReentrantLock();  
  4.       
  5.     public LockedMap(Map<K, V> map) {  
  6.         this.map = map;  
  7.     }  
  8.   
  9.     
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞