练习-模拟多线程访问资源

这个代码弄了两个类：MultipleTen/SynchronizedMultipleTen，其中前者是非线程安全的，后者是线程安全的。

package cn.edu.zsu.snippet.concurrent;

import java.util.logging.Logger;

import cn.edu.zsu.snippet.annotation.Run;

/**
 * 用来演示线程安全、同步
 * 
 * @author Justin
 * 
 */
public final class Synchronization {
	/**
	 * 
	 */
	private final Logger logger = Logger.getLogger(getClass().getName());

	/**
	 * 演示线程不安全的object的并发
	 */
	private void unsafe() {
		logger.info(String
				.format("演示非线程安全object的方法入口 %s", getClass().getName()));
		try {
			Ten ten = new MultipleTen();
			int counter = 0;
			while (counter++ < 10000) {
				Cracker c = new Cracker(ten);
				Shouter s = new Shouter(ten);
				c.start();
				s.start();
			}
		} finally {

		}
		logger.info(System.getProperty("line.separator"));
	}

	/**
	 * 演示线程安全的object并发
	 */
	private void safe() {
		logger.info(String.format("演示线程安全的object方法入口 %s", getClass().getName()));

		try {
			Ten ten = new SynchronizedMultipleTen(new MultipleTen());
			int counter = 0;
			while (counter++ < 1000) {
				Cracker c = new Cracker(ten);
				c.start();
				// service.execute(c);
				Shouter s = new Shouter(ten);
				s.start();
				// service.execute(s);
			}
		} finally {
		}
		logger.info(System.getProperty("line.separator"));
	}

	@Run
	public void exec() {
		logger.info(String.format("开始Synchronization的主函数 %s", getClass()
				.getName()));
		safe();
		unsafe();

	}
}

/**
 * 用来演示的接口
 * 
 * @author Justin
 * 
 */
interface Ten {
	public void increment();

	public int getCounter();
}

/**
 * <pre>
 * 非同步的Ten实现，方法体没有使用synchronized来进行限定
 * counter 也没有用volatile来修饰
 * </pre>
 * 
 * @author Justin
 * 
 */
class MultipleTen implements Ten {
	private int counter = 0;

	/**
	 * <p>
	 * 通过十次独立的自增操作给counter增加值，这里是产生不同步的根源。
	 * </p>
	 * <p>
	 * 可能会在没有完全执行完十次操作，counter值就被getCounter() 拿出去打印了。
	 * </p>
	 */
	public void increment() {
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
		counter++;
	}

	public int getCounter() {
		return counter;
	}
}

/**
 * Synchronized Decorator of "Ten"
 * 
 * @author Justin
 * 
 */
class SynchronizedMultipleTen implements Ten {
	private Ten ten;

	private Object mutex;

	public SynchronizedMultipleTen(Ten ten) {
		this.ten = ten;
		mutex = this;
	}

	@Override
	public void increment() {
		synchronized (mutex) {
			ten.increment();
		}
	}

	@Override
	public int getCounter() {
		synchronized (mutex) {
			return ten.getCounter();
		}
	}
}

/**
 * 负责给Ten进行增加操作。
 * 
 * @author Justin
 * 
 */
class Cracker extends Thread {
	// private final Logger logger = Logger.getLogger(getClass().getName());
	private Ten ten;

	public Cracker(Ten gen) {
		this.ten = gen;
	}

	@Override
	public void run() {
		super.run();
		ten.increment();
		// logger.info(String.format("current value == %d", ten.getCounter()));
	}
}

/**
 * 负责打印一个Ten实例
 * 
 * @author Justin
 * 
 */
class Shouter extends Thread {

	private Ten ten;
	private final Logger logger = Logger.getLogger(getClass().getName());

	public Shouter(Ten ten) {
		this.ten = ten;
	}

	@Override
	public void run() {
		final String pattern = "current value is : %d. it is not a multiple 10, produced by class : %s";
		super.run();
		int value = ten.getCounter();
		if (!(value % 10 == 0))
			logger.info(String.format(pattern, value, ten.getClass().getName()));
	}
}