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更更加高效。