概念：

     关键字 synchronized拥有锁重入的功能，也就是使用 synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时，可以再次得到此对象的锁。

适用场景：

  将一个大的业务逻辑拆成多个子方法逐个调用，若每个方法都是同步（synchronized）的，那么对象锁就会一直传递下去，被当前线程一直持有，若是其中又一个方法没有同步，则变成异步的了，放弃了对象锁，则可能有问题

例子程序01：方法拆分，方法调方法

/**
 * synchronized的重入
 *
 */
public class SyncDubbo1 {
	public synchronized void method1()  {
		System.out.println("method1...");
		method2();
	}

	public synchronized void method2() {
		System.out.println("method2...");
		method3();
		
	}
	public synchronized void method3() {
		System.out.println("method3...");
	}
	
	public static void main(String[] args) {
		final SyncDubbo1 syn = new SyncDubbo1();
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				syn.method1();
			}
		});
		t1.start();
	}
}

示例程序02 ：内部子类调用内部父类，共同修改相同成员变量，原子性

/**
 * synchronized的重入
 *
 */
public class SyncDubbo2 {
	
	static class Main {
		public int i = 10;
		public synchronized void operateionSup() {
			try {
				i--;
				System.out.println("Main print i = " + i);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	static class Sub extends Main {
		public synchronized void operateionSub() {
			try {
				while(i>0) {
					i--;
					System.out.println("Sub print i = " + i);
					Thread.sleep(100);
					this.operateionSup();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				Sub syn = new Sub();
				syn.operateionSub();
			}
		});
		t1.start();
	}
}

/* 执行结果
Sub print i = 9
Main print i = 8
Sub print i = 7
Main print i = 6
Sub print i = 5
Main print i = 4
Sub print i = 3
Main print i = 2
Sub print i = 1
Main print i = 0
*/

示例程序03 ： 出现异常，锁会自动释放

      对于web应用程序异常释放锁的情况，如果不及时处理，很可能会对你的业务应用逻辑产生严重的错误。

public class SyncException {
	
	private int i = 0;
	
	public synchronized void opration(){
		while(true) {
			try {
				i++;
				Thread.sleep(200);
				
				System.out.println(Thread.currentThread().getName() + " , i = " + i);
				if(i == 10) {
					Integer.parseInt("a");
				}
			} catch (Exception e) {
				//当有异常时，处理
				System.out.println("logger.info i = "+i);
				//throw new RuntimeException();
				continue;
			}
		}
	}

	public static void main(String[] args) {
		final SyncException se = new SyncException();
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				se.opration();
			}
		},"t1");
		t.start();
	}

}