一、传统的容器

Collection
|—-List |—-
ArrayList
                 |            |—-LinkList
                 |            |—-Vector—>线程安全
                 |
                 |
                 | —-Set |—-
TreeSet
                               |—-
HashSet

Map
—-
TreeMap
       —-
HashMap
       —-
HashTable
—>
线程安全

•     ArrayList集合的Demo

package com.itszt;

import java.util.ArrayList;
import java.util.List;

/**
* 
*
* 并发容器的选择
*
*/
public class Test3 {

    private static List<Integer> list = new ArrayList();

    public static void main(String[] args){
        //让5个线程去执行
        for (int i = 0; i < 50; i++) {
            new MyThread().start();
        }
    }

    private static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 1000; i++) {
                list.add(i);
            }
            System.out.println("集合大小：--->"+list.size());//我们预期的集合大小应该是50x1000=50000
        }
    }
}

运行结果：

        显而易见，集合的大小并没有我们预期的50000

        
当我们将ArrayList容器换成Vector时：

运行结果：

集合的大小达到了预期的大小，证明Vector容器是线程安全的

• HashMap的Demo

package com.itszt;

import java.util.*;

/**
* 
*
* 并发容器的选择
*
*/
public class Test3 {
    
//    private static Hashtable map = new Hashtable();
    private static Map<String,Integer> map = new HashMap<>();
    public static void main(String[] args){
        //让50个线程去执行
        for (int i = 0; i < 50; i++) {
            new MyThread().start();
        }
    }
    private static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 1000; i++) {

                map.put(UUID.randomUUID().toString(),i);

            }
                System.out.println("map集合的大小："+map.size());
        }
    }
}

运行结果：

集合的大小并没有达到我们预期的大小50000

当我们把HashMap换成Hashtable容器：

运行结果：

二、java5.0 JUC包提供了多种并发容器类来解决同步容器的性能问题

1.     ConcurrentHashMap

• ConcurrentHashMap同步容器类时Java5增加的一个线程安全的哈希表；介于HashMap与Hashtable之间，内部采用“锁分段”机制代替Hashtable的独占锁，进而提高了性能
• JUC包设计用于多线程上下文的Collection实现ConcurrentHashMap，ConcurrentSkipListMap，CopyOnWriteArrayList和CopyOnWriteArrarySet；
  • • • 当期望许多线程访问一个给定的collection时，ConcurrentHashMap通常优于同步的HashMap；ConcurrentSkipListMap通常优于同步的TreeMap
• 当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList优于同步的ArrayList

    2.    CountDownLatch（闭锁）

• CountDownLatch是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或者多这个线程一直等待

package com.itszt;

import java.util.concurrent.CountDownLatch;

/**
* 
*
* 计算多线程的执行时间
*
*/
public class TestCountDownLatch {
    public static void main(String[] args){

        final CountDownLatch latch = new CountDownLatch(10);
        LatchDemo latchDemo = new LatchDemo(latch);

        long start = System.currentTimeMillis();
        //创建是个线程
        for (int i = 0; i < 10; i++) {
            new Thread(latchDemo).start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
    }


}

class LatchDemo implements Runnable{

    private CountDownLatch latch;

    //有参构造器
    public LatchDemo(CountDownLatch latch){
        this.latch = latch;
    }

    @Override
    public void run() {

        synchronized (this){
            try {
                //打印50000以内的偶数
                for (int i = 0; i < 50000; i++) {
                    if (i%2==0) {
                        System.out.println(i);
                    }
                }
            }finally {
                //线程数量递减
                latch.countDown();
            }
        }
    }
}

运行结果：

在此，感谢各位好友的阅读，希望多提宝贵意见！谢谢