【并发8】线程安全-同步容器

文章内容精讲

本章主要讲了几种不安全容器 --  同步容器-- 后面讲 并发容器

同步容器主要采用synchronized修饰，而且有两种情况不安全1. 遍历又有增删改查操作时候 2. 同时删除，取得时候

前面讲到list等数据结构容器不安全，手动在这些地方容器访问的地方添加同步操作。Java提供现成的

分别介绍下：

* Vetor 和 stack 都用synchronized进行了修饰，vetor实现了List接口，stack实现了vetor，

* hashtable实现了MAP 接口，只是不能为空

* Collections.synchronizedXXX, 不同于Collection包，提供大量静态方法

这里给出几道面试题

java.text.SimpleDateFormat
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	 String ok = sdf.format(System.currentTimeMillis());
	 System.out.println(ok);
synchronized
锁标记，互斥锁，互斥锁标记，锁旗标，监视器
多线程高并发：
	1没事 ：没有并发错误的情况下就是慢而你没有感觉出来
	2慢：可以使用线程池减少大量创建和销毁的时间
	3出错：并发错误，加上锁
解决死锁：
	1.可行的话，改变锁标记出现的位置（顺序的排列锁标记，让每个线程依次拿取锁标记）这样会改变逻辑
	2.使用等待队列 使用Object类的wait() notify() notifyall()三个方法，必须持用锁标记才能调用。wait（）使当前线程A放弃所持有的锁标记，进入等待池内，线程B获得锁标记，再调用notify或notifyall方法释放在等待池中的线程，唤醒A线程，进入锁池等待获得锁标记。

01.	String  StringBuffer  StringBuilder 的区别？
1)	String：字符串常量，字符串长度不可变。Java中String是immutable（不可变）的。
2)	StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用StringBuffer，如果想转成String类型，可以调用StringBuffer的toString()方法。出现在JDK1.0
3)	StringBuilder：字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一个包含字符序列的变长数组。出现在JDK1.5
02.	HashMap和HashTable的区别？
1.同步特性不同
	HashMap 同一时间允许多个线程同时进行操作 效率较高 但是可能出现并发错误
	Hashtable 同一时间只允许一个线程进行操作 效率较低 但是不会出现并发错误
	*:JDK5.0开始 Collections.synchronizedMap(hashMap);

2.对于null的处理不同
	HashMap 无论主键还是值 都是可以存放null的 只不过主键要求唯一
		所以只能存放一个null
	Hashtable 无论主键还是值 都不允许存放null 会出现异常NullPointerException

3.底层实现的细节不同
	HashMap 默认分为16个小组 分组组数可以指定 但是最终结果一定是2的n次方
		正因为分组组数都是2的n次方 所以可以使用 &(分组组数-1)来计算散列
	Hashtable 默认分为11个小组 分组组数完全可以随意指定
		正因为如此 它不能使用&(分组组数-1) 而只能使用%分组组数

4.出现的版本不同
	HashMap		since JDK1.2
	Hashtable	since JDK1.0

接下来代码演示Vector的使用，在一般情况下是安全的，但是不有些情况下是有问题的，例如

安全的写法参考list
package com.mmall.concurrency.syncContainer;

import lombok.extern.slf4j.Slf4j;

import java.util.Vector;

@Slf4j
public class VoctorUnsafe {
    public static Vector<Integer> vector = new Vector<>();

    public static void main(String[] args) {
        while(true){
            //初始化数组向量容器
            for(int i = 0; i< 10; i++){
                vector.add(i);
            }
            // 定义两个线程，具有不同的操作
            Thread thread1 = new Thread(){
                public void run(){
                    for(int i = 0; i< vector.size(); i++){
                        vector.remove(i);
                    }
                }
            };

            Thread thread2 = new Thread(){
                public void run(){
                    for(int i = 0; i< vector.size(); i++){
                        vector.get(i);
                    }
                }
            };

            thread1.start();
            thread2.start();
        }
    }

}

 然后报错

Exception in thread "Thread-3422" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 6
	at java.util.Vector.remove(Vector.java:831)
	at com.mmall.concurrency.syncContainer.VoctorUnsafe$1.run(VoctorUnsafe.java:21)
Exception in thread "Thread-5402" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 35
	at java.util.Vector.remove(Vector.java:831)
	at com.mmall.concurrency.syncContainer.VoctorUnsafe$1.run(VoctorUnsafe.java:21)
Exception in thread "Thread-9526" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 0
	at java.util.Vector.remove(Vector.java:831)

仔细分析是因为在多线程下，两个线程同时执行到get 和remove 方法，刚要取数据，

却被另一个线程删除了，因此需要我们手动控制同步。

// 1
for(int i = 0; i< vector.size(); i++){
    vector.get(i);
}
// 2
for(int i = 0; i< vector.size(); i++){
    vector.remove(i);
}

接下来是HashTable 的用法，他是安全，参考hashMap的用法，换就得了。

接下来看Collections包下面创建的静态共享容器类, 同样，也有不安全的情况。

    //public static Map<Integer, Integer> map = new HashMap<>();
    public static Map<Integer, Integer> map = Collections.synchronizedMap(new HashMap<>());

//[list]
1  public static List<Integer> list = new ArrayList<Integer>();
2  public static List<Integer> list2 = Collections.synchronizedList(new ArrayList<>());
3  public static List<Integer> list = Collections.synchronizedList(Lists.newArrayList());

    //  public static Set<Integer> set = new HashSet<>();
    public static Set<Integer> set = Collections.synchronizedSet(Sets.newHashSet());

不安全的情况

package com.mmall.concurrency.syncContainer;

import com.mmall.concurrency.annotations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Iterator;
import java.util.Vector;

@Slf4j
@NotThreadSafe
public class VoctorUnsafe2 {

    // Exception in thread "main" java.util.ConcurrentModificationException
    //	at java.util.Vector$Itr.checkForComodification(Vector.java:1184)
    private static void test1(Vector<Integer> vector){//foreach
        // 知识点 ： integer有equals方法。 int 没有
        for ( Integer v1 : vector){
            if (v1.equals(3)){
                vector.remove(v1);
            }
        }
    }

    // 迭代器的使用
    private static void test2(Vector<Integer> vector){
        Iterator<Integer> iterator = vector.iterator();
        while (iterator.hasNext()){
            Integer i = iterator.next();
            if (i.equals(3)){
                vector.remove(i);
            }
        }
    }

    // 正常单线程的for循环
    private static void test3(Vector<Integer> vector){
        for (Integer i = 0; i< vector.size();i++){
            if (vector.get(i).equals(3)){
                vector.remove(i);
            }
        }
    }

    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();
        vector.add(1);
        vector.add(2);
        vector.add(3);
        test1(vector);

    }

}

分析解决方法：遍历的时候不做更新，要删除，就先做好标记，遍历完后在进行删除操作，

同步容器在进行遍历，正赶上另一个线程进行增删改查操作，就特别容易异常。

*  1. 所以在使用迭代循环时，使用synchronized 和 lock 操作。

*  2. 使用并发容器：CopyOnWriteArraySet / 并发容器代替vector / list.