java 线程同步类容器和并发类容器

同步类容器都是线程安全的，比如Vector，HashTable，这些容器的同步功能其实是由Collections.Synchronized.**等工厂方法去创建实现的，底层机制无非是用传统的synchronized关键字给每个公共方法进行同步，使得容器再同一时间只有一个线程访问，这些古老的同步类容器已经有点不适应当今的高并发互联网需求
某些场景下可能要加锁来保护复合类操作，复合类操作，比如：迭代，跳转（按指定顺序查找当前元素的下一元素），以及条件运算，这些复合操作在多线程并发的修改容器时，可能会出现意外的行为，比如ConcurrentModificationExcepiton，当容器迭代的过程中，被其他线程并发的修改了内容，这是因为早期设计迭代器的时候，并没有考虑到并发修改的问题
单独的并发修改，比如remove还是线程安全的：

public class Tickets {

    public static void main(String[] args) {
        //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList  HashTable替代HashMap
        
        final Vector<String> tickets = new Vector<String>();
        // 被Collections.synchronized**处理之后，map现在是线程安全的
        //Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());

        for(int i = 1; i<= 1000; i++){
            tickets.add("火车票"+i);
        }
        
//      for (Iterator iterator = tickets.iterator(); iterator.hasNext();) {
//          String string = (String) iterator.next();
//          tickets.remove(20);
//      }
        //单独的并发修改，比如remove还是线程安全的 ，remov并不是复合类操作
        for(int i = 1; i <=10; i ++){
            new Thread("线程"+i){
                public void run(){
                    while(true){
                        if(tickets.isEmpty()) break;
                        System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0));
                    }
                }
            }.start();
        }
    }
}

jdk5.0之后提供多种并发类容器来替代同步类容器来提高从而改善性能，同步类容器都是串行化的，多线程环境时，严重降低应用程序的吞吐量
- ConcurrentMap容器
  - ConcurrentHashMap
    对应的非并发容器：HashMap
    目标：代替Hashtable、synchronizedMap，支持复合操作
    原理：JDK6中采用一种更加细粒度的加锁机制Segment“分段锁”，减小锁的粒度，JDK8中采用CAS无锁算法，详细分析推荐阅读[【JDK】：ConcurrentHashMap高并发机制——【转载】(http://blog.csdn.net/u011080472/article/details/51392712)。
  - ConcurrentSkipListMap
    对应的非并发容器：TreeMap
    目标：代替synchronizedSortedMap(TreeMap)
    原理：Skip list（跳表）是一种可以代替平衡树的数据结构，默认是按照Key值升序的。Skip list让已排序的数据分布在多层链表中，以0-1随机数决定一个数据的向上攀升与否，通过”空间来换取时间”的一个算法。ConcurrentSkipListMap提供了一种线程安全的并发访问的排序映射表。内部是SkipList（跳表）结构实现，在理论上能够在O（log（n））时间内完成查找、插入、删除操作。
- CopyOnWrite容器，读写分离思想，适用于读多写少的场景，如果写多的话，可以使用synchronized锁
  - CopyOnWriteArrayList
    对应的非并发容器：ArrayList
    目标：代替Vector、synchronizedList
    原理：利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用，并通过volatile 保证其可见性，当然写操作的锁是必不可少的了。关于这一部分可参考【JDK】：CopyOnWriteArrayList、CopyOnWriteArraySet 源码解析
  - CopyOnWriteArraySet
    对应的费并发容器：HashSet
    目标：代替synchronizedSet
    原理：基于CopyOnWriteArrayList实现，其唯一的不同是在add时调用的是CopyOnWriteArrayList的addIfAbsent方法，其遍历当前Object数组，如Object数组中已有了当前元素，则直接返回，如果没有则放入Object数组的尾部，并返回。
    关于这一部分可参考【JDK】：CopyOnWriteArrayList、CopyOnWriteArraySet 源码解析
- 有序set
  - ConcurrentSkipListSet
    对应的非并发容器：TreeSet
    目标：代替synchronizedSortedSet
    原理：内部基于ConcurrentSkipListMap实现
- 队列
  - ConcurrentLinkedQueue，高并发无界队列，不允许null
    不会阻塞的队列
    对应的非并发容器：Queue
    原理：基于链表实现的FIFO队列（LinkedList的并发版本）
    add()和offer()都是添加元素，在此queue中没有任何区别
    poll()和peek()都是取第一个元素，前者会删除元素，后者不会
  - LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue，阻塞队列
    对应的非并发容器：BlockingQueue
    特点：拓展了Queue，增加了可阻塞的插入和获取等操作
    原理：通过ReentrantLock实现线程安全，通过Condition实现阻塞和唤醒
    实现类：
    LinkedBlockingQueue：基于链表实现的可阻塞的FIFO队列,无界队列
    ArrayBlockingQueue：基于数组实现的可阻塞的FIFO队列，有界队列
    PriorityBlockingQueue：按优先级排序的队列，元素必须实现comparable接口，判断优先级，无界队列，注意循环或者迭代该queue的时候，表现形式并不是优先级从高到底，而是执行take方法的时候，执行compare方法，有点懒加载的意思
    SynchronousQueue：没有没有缓冲的队列，Java 6的并发编程包中的SynchronousQueue是一个没有数据缓冲的BlockingQueue，生产者线程对其的插入操作put必须等待消费者的移除操作take，反过来也一样。不像ArrayBlockingQueue或LinkedListBlockingQueue，SynchronousQueue内部并没有数据缓存空间，你不能调用peek()方法来看队列中是否有数据元素，因为数据元素只有当你试着取走的时候才可能存在，不取走而只想偷窥一下是不行的，当然遍历这个队列的操作也是不允许的。队列头元素是第一个排队要插入数据的线程，而不是要交换的数据。数据是在配对的生产者和消费者线程之间直接传递的，并不会将数据缓冲数据到队列中。可以这样来理解：生产者和消费者互相等待对方，握手，然后一起离开。先有take，后有add。
    DelayQueue：带有延迟时间的queue，当延迟时间到了的时候，才能从队列里toke到该元素，必须实现Delayed接口，无界队列，
- Deque 双端队列(double ended queue)
  - LinkedBlockingDeque:线程安全的双端队列实现，并未实现读写分离，同一时间只能有一个线程对其进行操作，在高并发应用场景中性能要低于其他阻塞队列。
并发容器代码示例

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class UseConcurrentMap {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Object> chm = new ConcurrentHashMap<String, Object>();
        chm.put("k1", "v1");
        chm.put("k2", "v2");
        chm.put("k3", "v3");
                //如果key不存在则添加
        chm.putIfAbsent("k4", "vvvv");
        //System.out.println(chm.get("k2"));
        //System.out.println(chm.size());
        
        for(Map.Entry<String, Object> me : chm.entrySet()){
            System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
        }
    }
}

java 线程同步类容器和并发类容器

java 线程同步类容器和并发类容器

推荐阅读更多精彩内容

友情链接更多精彩内容

java 线程 同步类容器和并发类容器

推荐阅读更多精彩内容

友情链接更多精彩内容

java 线程同步类容器和并发类容器