多线程——并发容器类——Vector（同步容器）HashTable（同步），同步类容器的线程安全使用

1.容器的概述：

ConcurrentMap集合类使用与底层原理分析				
CopyOnWrite集合类使用与底层原理分析					
并发与阻塞队列Queue讲解							
模拟阻塞队列实战	
ArrayBlockingQueue
ConcurrentLinkedQueue
SynchronousQueue
PriorityBlockingQueue优先级队列
DelayQueue延迟队列应用与实战	

2.同步类容器的问题

同步类容器的状态都是串行化的。（100个请求，只有一个请求执行，执行后释放锁其他请求才能执行）

ConcurrentModificationException并发修改导致的当前线程更改异常

这些容器的同步功能其实都是有JDK的Collections.synchronized***等工厂方法去创建实现的。

    同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作。
    复合类操作如：迭代（反复访问元素，遍历完容器中所有的元素）、跳转（根
据指定的顺序找到当前元素的下一个元素）、以及条件运算。
    这些复合操作在多线程并发地修改容器时，可能会表现出意外的行为，最经典
的便是ConcurrentModificationException，原因是当容器迭代的过程中，被
并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑并发修改的问题

3.同步类容器的使用

        Vector、HashTable

同步类容器：
如Vector、HashTable。
    这些容器的同步功能其实都是有JDK的Collections.synchronized***等
工厂方法去创建实现的。
    其底层的机制无非就是用synchronized关键字对每个公用的方法都进行同
步，或者使用Object mutex对象锁的机制使得每次只能有一个线程访问容
器的状态。

 在一个同步类容器集合中，删除某个指定元素：m1();m2()方法会报异常ConcurrentModificationException。而m3()方法成功

package com.bfxy.thread.core.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;

public class UseSyncCollection {

    // 出现java.util.ConcurrentModificationException
    public Collection<String> m1(Vector<String> list) {
        for (String temp : list) {
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        return list;

    }
    // 出现java.util.ConcurrentModificationException
    public Collection<String> m2(Vector<String> list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String temp = iterator.next();
            if ("3".equals(temp)) {
                list.remove(temp);
            }
        }
        return list;

    }
    //successful!
    public Collection<String> m3(Vector<String> list) {
        for (int i = 0; i < list.size(); i++) {
            if ("3".equals(list.get(i))) {
                list.remove(i);
            }
        }
        return list;
    }


    public static void main(String[] args) {

    	Vector v = new Vector<>();
    	v.add("1");
    	v.add("2");
    	v.add("3");
    	UseSyncCollection test = new UseSyncCollection();
//		Collection<String> ret1 = test.m1(v);
//		System.err.println(ret1.toString());

//        Collection<String> ret2 = test.m2(v);
//        System.err.println(ret2.toString());

        Collection<String> ret3 = test.m1(v);
        System.err.println(ret3.toString());


//        List<String> list = new ArrayList<>();
//        Collections.synchronizedCollection(list);

    }
}

Vector（同步）方法大多用synchronized修饰与List（非同步）都能够使用方法3操作成功。

增强for循环以及游标循环对集合容器的数据操作不是一个线程在操作，简单for循环是单个线程操作

4.同步容器的实现：

1.其底层的机制无非就是用synchronized关键字对每个公用的方法都进行同步，

2.或者使用Object mutex对象锁的机制使得每次只能有一个线程访问容器的状态。

ConcurrentModificationException并发修改导致的当前线程更改异常

这些容器的同步功能其实都是有JDK的Collections.synchronized***等工厂方法去创建实现的。

//        List<String> list = new ArrayList<>();
//        Collections.synchronizedCollection(list);

这样就把List变成同步容器了，实现线程安全了：方法中会创建

new SynchronizedCollection(list);    

然后：SynchronizedCollection对象中有参数final Object mutex;（对象锁）

duilist操作时候都是对对象锁操作如：

        public int size() {
            synchronized (mutex) {return c.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return c.isEmpty();}
        }
        public boolean contains(Object o) {
            synchronized (mutex) {return c.contains(o);}
        }
        public Object[] toArray() {
            synchronized (mutex) {return c.toArray();}
        }
        public <T> T[] toArray(T[] a) {
            synchronized (mutex) {return c.toArray(a);}
        }

总结原理：会将list变成对象SynchronizedCollection；然后对list操作时候，会受到SynchronizedCollection对象中，mutex对象进行锁处理