java 5.0之前,还没有concurrent包的时候就有了一些用于并发的集合
- Vector 同步的ArrayList。
- Hashtable 同步的HashMap。
通过Collections.synchronized*(*);返回一个同步的集合。
但它们都是使用synchronized锁住整个集合,这会带来比较大的代价。
并且它们和其他非并发安全的集合一样,任务迭代过程中元素不会改变。如果迭代过程中删除一个元素(没用通过迭代器删除),那么会抛出一个异常。
Map<String, String> map = new HashMap<String, String>();
map.put("1", "test1");
map.put("2", "test2");
map.put("3", "test3");
map.put("4", "test4");
map = Collections.synchronizedMap(map);
for (String key : map.keySet()) {
if (key.equals("3")) {
map.remove(key);
}
System.out.println(map.get(key));
}
java.util.ConcurrentModificationException
at java.util.HashMap$HashIterator.nextNode(HashMap.java:1429)
at java.util.HashMap$KeyIterator.next(HashMap.java:1453)
concurrent包中的并发集合。主要有BlockingQueen、CurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet。
BlockingQueen,这是一个接口,主要增加了put 和take 方法,当读或者取队列时遇到空和满的情况会阻塞。jdk给出了五个实现
- ArrayBlockingQueue :一个由数组支持的有界队列。这要求队列有固定长度。
- LinkedBlockingQueue :一个由链接节点支持的可选有界队列。理论上队列可以无限长。
- PriorityBlockingQueue :一个由优先级堆支持的无界优先级队列。
- DelayQueue :一个由优先级堆支持的、基于时间的调度队列。
SynchronousQueue :一个利用 BlockingQueue 接口的简单聚集(rendezvous)机制。
堆本质是一颗完全二叉树,分大顶堆小顶堆。大顶堆根节点一定大于子节点,小顶堆反之。运用这个性质实现堆排序,复杂度为O(logn)。
//使用BlockingQueen的put和take可以便捷地实现生产消费模式。不会出现取到空值的状况。
public class Test {
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();
BlockingQueue<String> queen = new ArrayBlockingQueue<String>(10);//容量只有10;
for (int i = 0; i < 100; i++) {//100个线程生产
pool.execute(new Runnable() {
@Override
public void run() {
try {
queen.put("test");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
for (int i = 0; i < 100; i++) {//100个线程消费
pool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println((queen).take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
pool.shutdown();
while (true) {
if (pool.isTerminated())
break;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
CopyOnWriteArrayList 和 CopyOnWriteArraySet 这两个集合是应用于大量读而写操作较少的情况。对集合的写操作需要copy一个副本,对副本进行写操作,最后用更改过的副本替换原来的数据。而在更改之前就已经进行的遍历操作不会受影响,仍然迭代输出原有数据。 当然两者的区别是list是有序的set是无序的。
public class Test2 {
public static void main(String[] args) {
CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10; i++) {
set.add("test" + i);
list.add("test" + i);
}
for (String e : set) {
System.out.print(e + " ");
if (e.equals("test3")) {
set.add("testnew");
}
}
System.out.println();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
String e = it.next();
System.out.print(e + " ");
if (e.equals("test5"))
list.add("testnew");
}
System.out.println();
for (String e : set) {
System.out.print(e + " ");
}
System.out.println();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
System.out.print(it.next() + " ");
}
}
}
/*可以看到迭代中新增元素不会抛出异常,但新增的元素不会被本次迭代获取到。
*test0 test1 test2 test3 test4 test5 test6 test7 test8 test9
*test0 test1 test2 test3 test4 test5 test6 test7 test8 test9
*test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 testnew
*test0 test1 test2 test3 test4 test5 test6 test7 test8 test9 testnew
*/
最后看CurrentHashMap,这个是HashMap的同步版本,但和Hashtable不一样,CurrentHashMap内部用了更加细粒度的锁机制,不会锁住整个集合。比Hashtable更更加高效。