线程笔记(synchronized)

线程同步的实现方式有2种——方法同步和块同步，在java中会用到synchronized 这个关键字，它可以修饰：

• 非静态方法
• 静态方法
• 方法块

修饰方法时，注意不能是抽象类的抽象方法，也不能是接口中的方法。

如：

 写道

public synchronized void method1() {
//do something
}

public void method2() {
synchronized (this) {
//do something
}
}

public static synchronized void method3(){
//do something
}

 

 

下面一段文字 引自http://blog.csdn.net/yakihappy/article/details/3979905

  

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象（如 XXX.class）。

 

同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

 

 

上面的文字，前人总结得非常好也很精辟。在此主要是结合一些例子来理解上面的含义。

 

还是按照惯例，直接上代码：

 

public class ThreadSyncDemo {
	/**
	 * Group 1
	 */
	public synchronized void sync1_0() {
		System.out.println("sync1_0");
	}
	
	public synchronized void sync1_1() {
		System.out.println("sync1_1");
	}
	
	public void sync1_2() {
		synchronized (this) {
			System.out.println("sync1_2");
		}		
	}
	
	public void sync1_3() {
		System.out.println("before sync1_3");
		synchronized (this) {
			System.out.println("sync1_3");
		}	
		System.out.println("after sync1_3");
	}	
	
	
	/**
	 * Group 2
	 */
	public static synchronized void sync2_0(){
		System.out.println("sync2_0");
	}
	
	public static synchronized void sync2_1(){
		System.out.println("sync2_1");
	}

	public static void sync2_2() {
		synchronized (ThreadSyncDemo.class) {
			System.out.println("sync2_2");
		}		
	}
	
	public void sync2_3(){
		synchronized (ThreadSyncDemo.class) {
			System.out.println("sync2_3");
		}	
	}
	
	public void sync2_4(){
		synchronized (this.getClass()) {
			System.out.println("sync2_3");
		}	
	}
	
	/**
	 * Group 3
	 */
	private final Object lockObject = new Object();	
	public void sync3_0() {
		synchronized (lockObject) {
			System.out.println("sync3_0");
		}		
	}
	
	public void sync3_1() {
		synchronized (lockObject) {
			System.out.println("sync3_1");
		}		
	}	
	
	/**
	 * Group 4
	 */
	private final static Object SLockObject = new Object();
	public void sync4_0() {
		synchronized (SLockObject) {
			System.out.println("sync4_0");
		}		
	}
	
	public void sync4_1() {
		synchronized (SLockObject) {
			System.out.println("sync4_1");
		}		
	}
	
	public static void sync4_2() {
		synchronized (SLockObject) {
			System.out.println("sync4_2");
		}		
	}
}

 

首先对上述示例来个总结：

 

1. Group1中，共享数据为自身实例对象，对于同一个实例对象来说这组方法或块互斥。
2. Group2中，共享数据为类对象，对于此类或此类的实例对象，这组方法或块互斥。
3. Group3中，共享数据为自身实例对象的一个属性的值对象，对于同一个实例对象来说这组方法或块互斥。
4. Group4中，共享数据为类对象的一个静态属性的值对象，对于此类或此类的实例对象，这组方法或块互斥。
5. Group1/2/3/4之间无相关性。

简而言之，synchronized 关键字是用于保护共享数据，只有分清了共享数据，我们才知那些方法或块互为同步。

 

 

此外，上面的示例代码可以按下面的方法来测试：

 

public static void main(String[] args) {
		final ThreadSyncDemo tsd = new ThreadSyncDemo();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					tsd.sync4_0(); //
					try {
						Thread.sleep((int) (Math.random() * 1000));
					} catch (InterruptedException e) {
					}
				}

			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					ThreadSyncDemo.sync4_2(); //
					try {
						Thread.sleep((int) (Math.random() * 1000));
					} catch (InterruptedException e) {
					}
				}

			}
		}).start();
	}

 

使用eclipse在代码8和21行处加入断点，在调试模式下观察2个线程访问同步资源时的运行状态。第8/21行处的代码可以换Group1/2/3/4中的方法进行配对测试。