java大数据学习笔记（四） 并发集合

java 5.0之前，还没有concurrent包的时候就有了一些用于并发的集合

• Vector 同步的ArrayList。
• Hashtable 同步的HashMap。

• 通过Collections.synchronized*(*);返回一个同步的集合。

  但它们都是使用synchronized锁住整个集合，这会带来比较大的代价。
  并且它们和其他非并发安全的集合一样，任务迭代过程中元素不会改变。如果迭代过程中删除一个元素（没用通过迭代器删除），那么会抛出一个异常。

Map<String, String> map = new HashMap<String, String>();        map.put("1", "test1");        map.put("2", "test2");        map.put("3", "test3");        map.put("4", "test4");        map = Collections.synchronizedMap(map);        for (String key : map.keySet()) {            if (key.equals("3")) {                map.remove(key);            }            System.out.println(map.get(key));        }java.util.ConcurrentModificationException    at java.util.HashMap$HashIterator.nextNode(HashMap.java:1429)    at java.util.HashMap$KeyIterator.next(HashMap.java:1453)

concurrent包中的并发集合。主要有BlockingQueen、CurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet。

BlockingQueen，这是一个接口，主要增加了put 和take 方法，当读或者取队列时遇到空和满的情况会阻塞。jdk给出了五个实现

• ArrayBlockingQueue ：一个由数组支持的有界队列。这要求队列有固定长度。
• LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。理论上队列可以无限长。
• PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
• DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。

• SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

  堆本质是一颗完全二叉树，分大顶堆小顶堆。大顶堆根节点一定大于子节点，小顶堆反之。运用这个性质实现堆排序，复杂度为O(logn)。

//使用BlockingQueen的put和take可以便捷地实现生产消费模式。不会出现取到空值的状况。public class Test {    public static void main(String[] args) {        ExecutorService pool = Executors.newCachedThreadPool();        BlockingQueue<String> queen = new ArrayBlockingQueue<String>(10);//容量只有10；        for (int i = 0; i < 100; i++) {//100个线程生产            pool.execute(new Runnable() {                @Override                public void run() {                    try {                        queen.put("test");                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            });        }        for (int i = 0; i < 100; i++) {//100个线程消费            pool.execute(new Runnable() {                @Override                public void run() {                    try {                        System.out.println((queen).take());                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            });        }        pool.shutdown();        while (true) {            if (pool.isTerminated())                break;            try {                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

CopyOnWriteArrayList 和 CopyOnWriteArraySet 这两个集合是应用于大量读而写操作较少的情况。对集合的写操作需要copy一个副本，对副本进行写操作，最后用更改过的副本替换原来的数据。而在更改之前就已经进行的遍历操作不会受影响，仍然迭代输出原有数据。 当然两者的区别是list是有序的set是无序的。

public class Test2 {    public static void main(String[] args) {        CopyOnWriteArraySet<String>  set = new CopyOnWriteArraySet<String>();        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();        for (int i = 0; i < 10; i++) {            set.add("test" + i);            list.add("test" + i);        }        for (String e : set) {            System.out.print(e + " ");            if (e.equals("test3")) {                set.add("testnew");                }        }        System.out.println();        for (Iterator<String> it = list.iterator(); it.hasNext();) {            String e = it.next();            System.out.print(e + " ");            if (e.equals("test5"))                list.add("testnew");        }        System.out.println();        for (String e : set) {            System.out.print(e + " ");        }        System.out.println();        for (Iterator<String> it = list.iterator(); it.hasNext();) {            System.out.print(it.next() + " ");        }    }}/*可以看到迭代中新增元素不会抛出异常，但新增的元素不会被本次迭代获取到。*test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 *test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 *test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 testnew *test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 testnew */

最后看CurrentHashMap，这个是HashMap的同步版本，但和Hashtable不一样，CurrentHashMap内部用了更加细粒度的锁机制，不会锁住整个集合。比Hashtable更更加高效。