关于Java多线程和并发运行的学习（五）——并发 Collection

并发 Collection：

除队列外，java.util.concurrent包还提供了设计用于多线程上下文中的 Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。

当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步的HashMap，ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的ArrayList。

此包中与某些类一起使用的“Concurrent&rdquo前缀;是一种简写，表明与类似的“同步”类有所不同。例如，java.util.Hashtable 和Collections.synchronizedMap(new HashMap()) 是同步的，但 ConcurrentHashMap 则是“并发的”。并发 collection 是线程安全的，但是不受单个排他锁的管理。在 ConcurrentHashMap 这一特定情况下，它可以安全地允许进行任意数目的并发读取，以及数目可调的并发写入。需要通过单个锁不允许对 collection 的所有访问时，“同步”类是很有用的，其代价是较差的可伸缩性。在期望多个线程访问公共 collection 的其他情况中，通常“并发”版本要更好一些。当 collection 是未共享的，或者仅保持其他锁时 collection 是可访问的情况下，非同步 collection 则要更好一些。

大多数并发 Collection 实现（包括大多数 Queue）与常规的 java.util 约定也不同，因为它们的迭代器提供了弱一致的，而不是快速失败的遍历。弱一致的迭代器是线程安全的，但是在迭代时没有必要冻结 collection，所以它不一定反映自迭代器创建以来的所有更新。

在这里实现一下CopyOnWriteArrayList()的案例：

User.java:

package Multithreading;

public class User implements Cloneable {
	private String name;
	private int age;

	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof User)) {
			return false;
		}
		User user = (User) obj;
		// if(this.name==user.name && this.age==user.age)
		if (this.name.equals(user.name) && this.age == user.age) {
			return true;
		} else {
			return false;
		}
	}

	public int hashCode() {
		return name.hashCode() + age;
	}

	public String toString() {
		return "{name:'" + name + "',age:" + age + "}";
	}

	public Object clone() {
		Object object = null;
		try {
			object = super.clone();
		} catch (CloneNotSupportedException e) {
		}
		return object;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}
}

CollectionModifyExceptionTest.java:

package Multithreading;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

public class CollectionModifyExceptionTest {
	public static void main(String[] args) {
		Collection users = new CopyOnWriteArrayList();
		// new ArrayList();//在这里迭代时是不能做删除的
		users.add(new User("张三", 28));
		users.add(new User("李四", 25));
		users.add(new User("王五", 31));
		Iterator itrUsers = users.iterator();
		while (itrUsers.hasNext()) {
			System.out.println("*************");
			User user = (User) itrUsers.next();
			if ("李四".equals(user.getName())) {
				users.remove(user);//这里涉及到了对列表的多线程操作
				// itrUsers.remove();//这里是对迭代器的操作
			} else {
				System.out.println(user);
			}
		}
	}
}

运行的结果是：

在这里，使用CopyOnWriteArrayList()的好处就是，在列表读的时候也可以进行其他操作，并发运行不会抛出异常。如果使用单纯的LinkedList()，在遍历读取的时候，就不可以对列表本身进行其他操作。

这里写一个关于LinkedList()的小例子，与CopyOnWriteArrayList()相对比：

package Day04;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * 使用迭代器遍历集合
 * @author Administrator
 *
 */
public class IteratorDemo {
	public static void main(String[] args) {
		List list = new LinkedList();
		list.add("1");
		list.add("#");
		list.add("2");
		list.add("#");
		list.add("3");
		list.add("#");
		list.add("4");

		//获取用于遍历集合的迭代器  java.util.Iterator
		Iterator it = list.iterator();
		
		while(it.hasNext()){
			String element = (String)it.next();
			if("#".equals(element)){
				//list.remove(element);//报错：ConcurrentModificationException
				it.remove();//删除刚被迭代出来的元素
				/*
				 * 应该在迭代器中删除迭代出来的元素，不可以在集合中直接删除元素！！！
				 */
			}
		}
		System.out.println(list);
	}
}

运行结果：

在LinkedList()中只能对迭代器进行操作，让迭代器移除需要移除的元素，而CopyOnWriteArrayList()中，可以直接对列表进行操作，删除需要移除的元素。

这里还有另外一种线程安全的方法，就是将非线程安全的转换为线程安全的，所有的集合都支持一个以参数为:Collection的构造方法，这个构造方法的作用可以在创建当前集合的基础上,将给定的几个元素放入其中，这个构造方法通常习惯叫它为:集合的复制构造器。

package Day05;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

/**
 * 获取线程安全的集合
 * @author Administrator
 */
public class SyncAPIDemo {
	public static void main(String[] args) {
		//List集合   ArrayList集合不是线程安全的
		List<String> list = new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		List<String> vector = new Vector<String>(list);
		//将List转换为HashSet
		Set<String> hashset = new HashSet<String>(list);
		System.out.println(vector);
		System.out.println(hashset);
		/**
		 * 使用Collections的方法,可以方便的将一个集合变成线程安全的
		 */
		
		List<String> syncList = Collections.synchronizedList(list);
		System.out.println("syncList"+syncList);
		Set<String> syncSet = Collections.synchronizedSet(hashset);
		System.out.println("syncSet:" + syncSet);
		
		HashMap<String,Integer> map = new HashMap<String,Integer>();
		
		map.put("one", 1);
		map.put("two", 2);
		map.put("three",3);
		/**
		 * 将hashmap转换为一个线程安全的map
		 */
		Map<String,Integer> syncmap = Collections.synchronizedMap(map);
		System.out.println("syncmap:" + syncmap);
	}
}