java并发编程（四）同步工具类

	public long timeTasks(int nThread, final Runnable task)
			throws InterruptedException {

		final CountDownLatch startGate = new CountDownLatch(1);
		final CountDownLatch endGate = new CountDownLatch(nThread);

		for (int i = 0; i < nThread; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					try {
						startGate.await();

						try {
							task.run();
						} finally {
							endGate.countDown();
						}

					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					task.run();

				}
			}).start();
		}

		long start = System.nanoTime();
		startGate.countDown();
		endGate.await();
		long end = System.nanoTime();

		return end - start;

	}

FutureTask

public class PreLoader {

	private final FutureTask<ProductInfo> future = new FutureTask<ProductInfo>(
			new Callable<ProductInfo>() {

				@Override
				public ProductInfo call() throws Exception {
					return loaderProductInfo();
				}
			});

	private final Thread thread = new Thread(future);

	public void start() {
		thread.start();
	}

	public ProductInfo get() throws DataLoadException, InterruptedException {
		try {
			return future.get();
		} catch (ExecutionException e) {
			Throwable cause = e.getCause();
			if (cause instanceof DataLoadException)
				throw (DataLoadException) cause;
			else
				throw launderThrowable(cause);
		}
	}

	private static RuntimeException launderThrowable(Throwable t) {

		if (t instanceof RuntimeException)
			return (RuntimeException) t;
		else if (t instanceof Error)
			throw (Error) t;
		else
			throw new IllegalStateException("Not unchecked ", t);

	}

	ProductInfo loaderProductInfo() {
		// 耗时事件
		return null;
	}

}

public class BoundedHash<T> {

	private final Set<T> set;
	private final Semaphore sem;

	public BoundedHash(int permits) {
		set = Collections.synchronizedSet(new HashSet<T>());
		sem = new Semaphore(permits);
	}

	public boolean add(T t) throws InterruptedException {
		sem.acquire();
		boolean wasAdded = false;
		try {
			wasAdded = set.add(t);
			return wasAdded;
		} finally {
			if (!wasAdded)
				sem.release();
		}
	}

	public boolean remove(T t) {
		boolean wasRemoved = set.remove(t);
		if (wasRemoved)
			sem.release();
		return wasRemoved;
	}

}

public class CellularAutomata {

	private final Board mainBoard;
	private final CyclicBarrier barrier;
	private final Worker[] workers;

	public CellularAutomata(Board board) {
		this.mainBoard = board;
		int count = Runtime.getRuntime().availableProcessors();
		this.barrier = new CyclicBarrier(count, new Runnable() {

			@Override
			public void run() {

			}
		});
		this.workers = new Worker[count];
		for (int i = 0; i < count; i++) {
			workers[i] = new Worker(mainBoard.getSubBoard(count, i));
		}

	}

	private class Worker implements Runnable {
		private final Board board;

		public Worker(Board board) {
			this.board = board;
		}

		@Override
		public void run() {
			while (!board.hasConvergeted()) {
				for (int i = 0; i < board.getMaxx(); i++)
					for (int j = 0; j < board.getMaxy(); j++)
						board.setNewValue(i, j, computeValue(i, j));
				try {
					barrier.await();	//等待 直到达到线程数
				} catch (InterruptedException | BrokenBarrierException e) {
					return;
				}
			}
		}

	}

	public void start() {
		for (int i = 0; i < workers.length; i++) {
			new Thread(workers[i]).start();
			mainBoard.waitForConvergence();
		}
	}

}

interface Computable<K, V> {

	V compute(K arg) throws InterruptedException;

}

public class Memoizer<K, V> implements Computable<K, V> {

	private final Map<K, Future<V>> cache = new ConcurrentHashMap<K, Future<V>>();
	private final Computable<K, V> c;

	public Memoizer(Computable<K, V> c) {
		this.c = c;
	}

	@Override
	public V compute(K arg) throws InterruptedException {
		while (true) {
			Future<V> f = cache.get(arg);
			if (f == null) {
				Callable<V> eval = new Callable<V>() {

					@Override
					public V call() throws Exception {
						return c.compute(arg);
					}
				};
				FutureTask<V> ft = new FutureTask<V>(eval);
				f = cache.put(arg, ft);
				if (f == null) {
					f = ft;
					ft.run();
				}
			}

			try {
				return f.get();
			} catch (CancellationException e) {
				cache.remove(arg, f);
			} catch (ExecutionException e) {
				throw new InterruptedException();
			}

		}
	}

}

• 可变状态是至关重要的

• 尽量将域生命为final类型，除非需要它们是可变的。
• 不可变对象一定是线程安全的。

• 封装有助于管理复杂性

• 用锁来保护每个可变对象。
• 当保护同一个不变性条件中的所有变量时，要使用同一个锁。
• 在执行符合操作期间，要持有锁。
• 如果从多个线程中访问同一个可变变量时没有同步机制，那么程序会出现问题。
• 不要故作聪明的推断出不需要使用同步。
• 在设计过程中考虑线程安全，或者在文档中明确地指出不是线程安全的。
• 将同步策略文档化。