《java并发编程实战》基础构建模块（一）

• 同步容器类包括Vector和Hashtable，与之对应的非同步的容器是ArrayList和HashMap

例一

package com.imeiren.java;

import java.util.Vector;

public class Main {
	public static void main(String[] args) {
		final Vector<String> vector = new Vector<String>();

		for (int i = 0; i < 10; i++) {
			vector.add(Integer.toString(i));
		}

		Thread getThread = new Thread(new Runnable() {

			@Override
			public void run() {
				getLast(vector);
			}
		});

		Thread deleteThread = new Thread(new Runnable() {

			@Override
			public void run() {
				deleteLast(vector);
			}
		});

		getThread.start();
		deleteThread.start();
	}

	public static Object getLast(Vector vector) {
		int lastIndex = vector.size() - 1;
		return vector.get(lastIndex);
	}

	public static void deleteLast(Vector vector) {
		int lastIndex = vector.size() - 1;
		vector.remove(lastIndex);
	}
}

有两个线程同时操作一个集合Vector，一个线程是做get操作，另一个线程是做remove操作。有可能会出现下面这个异常：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 9
	at java.util.Vector.get(Unknown Source)
	at com.imeiren.java.Main.main(Main.java:16)

也就是在两个方法获得的lastIndex是相同的，然后先remove，再get，这样就出错了。

类似单线程下这段代码：

		int lastIndex = vector.size() - 1;
		if (lastIndex >= 0) {
			vector.remove(lastIndex);
			vector.get(lastIndex);
		}

所以我们需要对集合加锁。

例二

package com.imeiren.java;

import java.util.Vector;

public class Main {
	public static void main(String[] args) {
		final Vector<String> vector = new Vector<String>();

		for (int i = 0; i < 10; i++) {
			vector.add(Integer.toString(i));
		}

		Thread getThread = new Thread(new Runnable() {

			@Override
			public void run() {
				int size = vector.size();
				for (int i = 0; i < size; i++) {
					System.out.println(vector.get(i));
				}
			}
		});

		Thread deleteThread = new Thread(new Runnable() {

			@Override
			public void run() {
				int size = vector.size();
				if (size >= 1) {
					vector.remove(size - 1);
				}
			}
		});

		getThread.start();
		deleteThread.start();
	}
}

同样是两个线程，一个线程遍历所有的元素输出，另一个线程删除最后一个元素。这段代码会抛出异常：

Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 9
	at java.util.Vector.get(Unknown Source)
	at com.imeiren.java.Main$1.run(Main.java:19)
	at java.lang.Thread.run(Unknown Source)

所以在单线程下安全的一些代码，在并发情况下并不见得就是线程安全的。

例三

				for (String string : vector) {
					vector.remove(string);
				}

假如我们遍历一个集合，并依次删除其元素。这样的方式是会抛出下面这个异常：

Exception in thread "Thread-1" java.util.ConcurrentModificationException
	at java.util.AbstractList$Itr.checkForComodification(Unknown Source)
	at java.util.AbstractList$Itr.next(Unknown Source)
	at com.imeiren.java.Main$2.run(Main.java:27)
	at java.lang.Thread.run(Unknown Source)

这个在单线程情况下也会发生。

例四

package com.imeiren.java;

import java.util.Vector;

public class Main {
	public static void main(String[] args) {
		final Vector<String> vector = new Vector<String>();

		for (int i = 0; i < 10; i++) {
			vector.add(Integer.toString(i));
		}

		Thread getThread = new Thread(new Runnable() {

			@Override
			public void run() {
				for (String string : vector) {
					System.out.println(string);
				}
			}
		});

		Thread deleteThread = new Thread(new Runnable() {

			@Override
			public void run() {
				int size = vector.size();
				if (size >= 1) {
					vector.remove(size-1);
				}
			}
		});

		getThread.start();
		deleteThread.start();
	}
}

同样是两个线程，一个线程进行遍历输出，另一个线程进行删除操作。这段代码会抛出下面这个异常：

Exception in thread "Thread-0" java.util.ConcurrentModificationException
	at java.util.AbstractList$Itr.checkForComodification(Unknown Source)
	at java.util.AbstractList$Itr.next(Unknown Source)
	at com.imeiren.java.Main$1.run(Main.java:17)
	at java.lang.Thread.run(Unknown Source)

为了避免这个异常我们一般情况是对集合进行加锁：

		Thread getThread = new Thread(new Runnable() {

			@Override
			public void run() {
				synchronized (vector) {
					for (String string : vector) {
						System.out.println(string);
					}
				}
			}
		});

这样在遍历输出线程中持有集合对象的锁，在这个操作期间其他需要操作集合的线程都必须进入等待状态。故可解决并发修改异常。

然而开发者并不希望这样加个锁在大的集合上面。那么另外一个解决的方法就是克隆容器，在副本上面进行操作。如

				Vector<String> copy = (Vector<String>) vector.clone();
				for (String string : copy) {
					System.out.println(string);
				}

当然克隆也是需要一定的开销。这个时候就需要根据实际情况来选择使用哪种解决方案。

例五

package com.imeiren.java;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class HiddenIterator {
	private final Set<Integer> set=new HashSet<Integer>();

	public synchronized void add(Integer integer){
		set.add(integer);
	}

	public synchronized void remove(Integer integer){
		set.remove(integer);
	}

	public void addTenThings() {
		Random r=new Random();
		for (int i = 0; i < 10; i++) {
			add(r.nextInt());
		}
		System.out.println(set);
	}
}

假如我们有这样一个类，其中一个addTenThings往一个集合里面添加10个元素，并输出集合。

我们的测试代码如下：

package com.imeiren.java;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
	public static void main(String[] args) {
		final HiddenIterator obj = new HiddenIterator();

		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 5; i++) {
			executorService.execute(new Runnable() {

				@Override
				public void run() {
					obj.addTenThings();
				}
			});
		}

		executorService.shutdown();
	}
}

开一个线程池来执行5个并发线程往集合里面添加元素。我们会得到下面这个异常：

Exception in thread "pool-1-thread-4" java.util.ConcurrentModificationException
	at java.util.HashMap$HashIterator.nextEntry(Unknown Source)
	at java.util.HashMap$KeyIterator.next(Unknown Source)
	at java.util.AbstractCollection.toString(Unknown Source)
	at java.lang.String.valueOf(Unknown Source)
	at java.io.PrintStream.println(Unknown Source)
	at com.imeiren.java.HiddenIterator.addTenThings(HiddenIterator.java:23)
	at com.imeiren.java.Main$1.run(Main.java:16)
	at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)

针对上面的代码，我们有两个解决方案。第一，对输出部分上锁：

	public void addTenThings() {
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			add(r.nextInt());
		}
		synchronized (this) {
			System.out.println(set);
		}
	}

我们看到add方法其实是已经加锁，只是下面的println方法需要加锁。这样两次对集合的操作都已经加锁，我们开15个线程来测试也没出现问题。

第二个解决方案是对整个addTenThings加锁：

	public synchronized void addTenThings() {
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			set.add(r.nextInt());//注意这里换成直接操作set
		}
		System.out.println(set);
	}