Java synchronize 与 static synchronize 方式对比

另一篇博文写的比我这个好，争取有一天可以写的跟他一样清楚，有需要的同志移步： http://blog.csdn.net/cs408/article/details/48930803

package Joey.Java.Test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/*
 * synchronize 与 static synchronize 方式对比
 */
public class ExecutorExam {
	public static void main(String[] args)
	{
		ExecutorService service = Executors.newCachedThreadPool();
		service.execute(new Task("Task1"));
		service.execute(new Task("Task2"));
		service.execute(new Task("Task3"));
		service.shutdown();
	}
}

class Task implements Runnable {

	//事实上，这个count在这个类里面，只有是static时，才用static synchronize关键字锁住，因为他要保证三个实例之间互斥
	//如果他是私有字段，那么synchronize不保证三个实例之间互斥，只能保证本实例在不同的线程间互斥，所以加synchronize必须要主要应用场合
	/*从结果中我们得知每个实例自己内部调用次数是同步的，但是注意这里每个实例都是一个线程在执行，所以必然同步，完全不需要synchronize也可以做到如此执行
	 * 运行结果如下：
		Task3-[0],  called: 1
		Task1-[0],  called: 1
		Task2-[0],  called: 1
		Task1-[1],  called: 2
		Task2-[1],  called: 2
		Task3-[1],  called: 2
		Task2-[2],  called: 3
		Task1-[2],  called: 3
		Task3-[2],  called: 3
		Task3-[3],  called: 4
		Task1-[3],  called: 4
		Task2-[3],  called: 4
		Task3-[4],  called: 5
		Task1-[4],  called: 5
		Task2-[4],  called: 5
	 */
	private int count = 0;
	private final String name;
	/*
	 * 对于Counter 类注意一点，它自身内部是用 static synchronized关键字修饰，所以他能够保证在多个实例之间的同步，
	 * 运行结果如下：
		Task1-[0],  called: 1
		Task3-[0],  called: 2
		Task2-[0],  called: 3
		Task3-[1],  called: 4
		Task1-[1],  called: 5
		Task2-[1],  called: 6
		Task3-[2],  called: 7
		Task2-[2],  called: 8
		Task1-[2],  called: 9
		Task2-[3],  called: 10
		Task1-[3],  called: 11
		Task3-[3],  called: 12
		Task3-[4],  called: 13
		Task1-[4],  called: 14
		Task2-[4],  called: 15
	 */
	private Counter counter=new Counter();
	
	Task(String name)
	{
		this.name = name;
	}
	@Override
	public void run() {
		for(int i=0;i<5;i++)
		{
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//increase(name, i);
			counter.increase(name, i);
		}
	}
	
	private synchronized void increase(String name, int i)
	{
		count++;
		System.out.println(name + "-["+i+"],  called: "+count);
	}
}

class Counter 
{
	private static int count=0;
	public static synchronized int increase(String name, int i)
	{
		count++;
		System.out.println(name + "-["+i+"],  called: "+count);
		return count;
	}
}