Java的高并发编程系列（九）并发性容器

ConcurrentMap

public class T01_ConcurrentMap {

    public static void main(String[] args) {
        Map<String, String> map = new ConcurrentHashMap<String, String>();
        //Map<String, String> map = new ConcurrentSkipListMap<String, String>(); //高并发并且排序

        //Map<String, String> map = new Hashtable<>();
        //Map<String, String> map = new HashMap<String, String>();

        Random random = new Random();
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);
        long start = System.currentTimeMillis();
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(()->{
                for(int j=0; j<10000;j++) map.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
                latch.countDown();
            });
        }

        Arrays.asList(threads).forEach(t->t.start());
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

启动100个线程，向图中添加100000个元素，分别使用Hashtable，HashMap，ConcurrentHashMap，ConcurrentSkipListMap定义map，判断程序完成的时间。最终发现，ConcurrentHashMap要比HashMap效率高，ConcurrentHashMap是将大锁分成若干小锁，实现多个线程共同运行，所以，效率有很大差距。ConcurrentSkipListMap较ConcurrentHashMap除了实现高并发外还能够排序。

参考：
http://blog.csdn.net/sunxianghuang/article/details/52221913
http://www.educity.cn/java/498061.html

---

CopyOnWriteList（写时复制容器）

多线程环境下，写时效率低，读时效率高，适合写少读多的环境。

public class T02_CopyOnWriteList {

    public static void main(String[] args) {
        List<String> lists = 
                //new ArrayList<String>(); //这个会出并发问题
                //new Vector<String>();
                new CopyOnWriteArrayList<String>();
        Random r = new Random();
        Thread[] threads = new Thread[100];

        for (int i = 0; i < threads.length; i++) {
            Runnable task = new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        lists.add("a" + r.nextInt(10000));
                    }
                }
            };
            threads[i] = new Thread(task);
        }

        runAndComputeTime(threads);

        System.out.println(lists.size());
    }

    private static void runAndComputeTime(Thread[] threads) {
        long start = System.currentTimeMillis();
        Arrays.asList(threads).forEach(t->t.start());
        Arrays.asList(threads).forEach(t->{
            try {
                t.join(); //join等线程执行完之后再往下执行
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

SynchronizeList（同步集合）

    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        List<String> synchronizedList = Collections.synchronizedList(arrayList); //此时的集合是同步的

    }

ConcurrentQueue（并发队列）

public class T04_ConcurrentQueue {

    public static void main(String[] args) {
        Queue<String> strings = new ConcurrentLinkedQueue<String>();

        for (int i = 0; i < 10; i++) {
            strings.offer("a" + i); //相当于add， 放进队列
        }

        System.out.println(strings);

        System.out.println(strings.size());

        System.out.println(strings.poll()); //取出并移除掉
        System.out.println(strings.size());

        System.out.println(strings.peek()); //取出，不会移除。相当于get(0)
        System.out.println(strings.size());
    }
}

LinkedBlockingQueue

public class T05_LinkedBlockingQueue {

    private static BlockingQueue<String> strings = new LinkedBlockingQueue<String>();
    private static Random r = new Random();

    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    strings.put("a" + i); //如果满了，就会等待
                    TimeUnit.SECONDS.sleep(r.nextInt(10));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "p1").start();

        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                for(;;){
                    try {
                        System.out.println(Thread.currentThread().getName() + "take -" + strings.take()); //如果空了，就会等待
                    } catch (Exception e) {
                        e.printStackTrace();
                    } 
                }
            },"c" + i).start();
        }
    }
}

LinkedBlockingQueue是使用链表是实现的阻塞式容器。

ArrayBlockingQueue（有界队列）

能装的内容是有限的。

public class T06_ArrayBlockingQueue {

    private static BlockingQueue<String> strings = new ArrayBlockingQueue<String>(10);

    private static Random r = new Random();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            strings.put("a" + i);
        }

        //strings.put("aaaa"); //满了就会等待，程序阻塞
        strings.add("aaaa");
        //strings.offer("aaaa");
        strings.offer("aaaa", 1, TimeUnit.SECONDS);

        System.out.println(strings);
    }
}

DelayQueue

public class T07_DelayQueue {

    private static BlockingQueue<MyTask> tasks = new DelayQueue<>();
    private static Random r = new Random();

    static class MyTask implements Delayed{

        long runningTime;

        public MyTask(long rt) {
            this.runningTime = rt;
        }

        @Override
        public int compareTo(Delayed o) {
            if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MICROSECONDS)) {
                return -1;
            }else if (this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) {
                return 1;
            }else {
                return 0;
            }
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public String toString() {
            return "" + runningTime;
        }

        public static void main(String[] args) throws InterruptedException {
            long now = System.currentTimeMillis();
            MyTask t1 = new MyTask(now + 1000);
            MyTask t2 = new MyTask(now + 2000);
            MyTask t3 = new MyTask(now + 1500);
            MyTask t4 = new MyTask(now + 2500);
            MyTask t5 = new MyTask(now + 500);

            tasks.put(t1);
            tasks.put(t2);
            tasks.put(t3);
            tasks.put(t4);
            tasks.put(t5);

            System.out.println(tasks);

            for (int i = 0; i < 5; i++) {
                System.out.println(tasks.take());
            }
        }
    }
}

TransferQueue

消费者线程先启动，后生产中生产一个首先看有没有消费者，直接给消费者，不往队列中放。常用于更高的并发中。

public class T08_TransferQueue {

    public static void main(String[] args) throws InterruptedException {
        LinkedTransferQueue<String> strings = new LinkedTransferQueue<String>();

        /*new Thread(()->{
            try {
                System.out.println(strings.take());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();*/

        //strings.transfer("aaa");

        strings.put("aaa");

        new Thread(()->{
            try {
                System.out.println(strings.take());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}

Synchronized （同步队列）

public class T09_Synchronized {

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> strings = new SynchronousQueue<String>();

        new Thread(()->{
            try {
                System.out.println(strings.take());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        strings.put("aaa"); //阻塞等待消费者消费
        //strings.add("aaa");
        System.out.println(strings.size());
    }
}