Synchronized对象加锁防止并发

前言：处理简单的并发可以给对象加把锁，防止不同线程对同一资源同时进行操作，但是也需要谨慎使用"synchronized "关键字。
1、同步锁

package com.boonya.concurrent;

/**
 * Java同步锁
 * 
 * @author [e-mail] 熟悉一下Synchronized的用法 写法
 */
public class SynchronizedInJava {

	/**
	 * 某线程执行method1()方法，则该对象将加锁。其它线程将无法执行该对象的所有synchronized块。
	 */
	public synchronized void method1() {
		// ....;
	}

	/**
	 * 同用法1, 但更能体现synchronized用法的本质。
	 */
	public void method2() {
		// 锁住本对象
		synchronized (this) {
			// ...;
		}
	}

	/**
	 * 测试方法3 执行method3()，会给对象a加锁，注意不是给SynchronizedInJava的对象加锁，也就是说 Test
	 * 对象的其它synchronized方法不会因为method3()而被锁。同步代码块执行完，则释放对a的锁。
	 */
	private String a = "test";

	public void method3() {
		// 锁住a对象
		synchronized (a) {
			// ...;
		}
	}

	public synchronized void t() {
		//这个同步代码块不会因为method3()而锁定.
		// ...; 
	}

	/**
	 * 为了锁住一个对象的代码块而不影响该对象其它 synchronized块的高性能写法
	 */
	private byte[] lock = new byte[0];

	public void method4() {
		synchronized (lock) {
			// ...;
		}
	}

	public synchronized void td() {
		// ...;
	}

	/**
	 * 静态方法锁
	 */
	public synchronized static void execute1() {
		// ...;
	}

	// 效果同上(静态方法锁)
	public static void execute2() {
		synchronized (SynchronizedInJava.class) {
			// ...;
		}
	}

}

2、死锁
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。 导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。 由于这个原因，在使用“synchronized”关键词时，很容易出现两个线程互相等待对方做出某个动作的情形。

package com.boonya.concurrent;

/**
 * 模拟死锁出现的情景
 * 
 * @author [e-mail] 假设先调用 method1()
 *         首先lock_1对象被锁住，lock_2被锁住，lock_1直到lock_2执行完成后方才解锁；
 *         在method1执行的间隙，method2()被调用，由于lock_1、lock_2被锁定，造成线程阻塞，产生死锁。
 */
public class SynchronizedDeadlocker {

	int field_1;
	private Object lock_1 = new int[1];

	int field_2;
	private Object lock_2 = new int[1];

	public void method1(int value) {
		synchronized (lock_1) {
			synchronized (lock_2) {
				field_1 = 0;
				field_2 = 0;
			}
		}
	}

	public void method2(int value) {
		synchronized (lock_2) {
			synchronized (lock_1) {
				field_1 = 0;
				field_2 = 0;
			}
		}
	}
}

注：在实际生产环境中还是要考虑是否会产生死锁，避免灾难的发生。
参考资源：http://dapple.iteye.com/blog/787563