synchronized 关键字解析
同步锁依赖于对象，每个对象都有一个同步锁。
现有一成员变量 Test，当线程 A 调用 Test 的 synchronized 方法，线程 A 获得 Test 的同步锁，同时，线程 B 也去调用 Test 的 synchronized 方法，此时线程 B 无法获得 Test 的同步锁，必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码。
综上，正确使用 synchronized 关键字可确保原子性。
synchronized 关键字的特性应用
特性 1：
当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的synchronized 方法 或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。
DEMO1，synchronized 方法：
public class Test { private static class Counter { public synchronized void count() { for (int i=0; i < 6; i++) { System.out.println(Thread.currentThread().getName() + "， i=" + i); } } } private static class MyThread extends Thread { private Counter mCounter; public MyThread(Counter counter) { mCounter=counter; } @Override public void run() { super.run(); mCounter.count(); } } public static void main(String[] var0) { Counter counter=new Counter(); // 注：myThread1 和 myThread2 是调用同一个对象 counter MyThread myThread1=new MyThread(counter); MyThread myThread2=new MyThread(counter); myThread1.start(); myThread2.start(); } }
DEMO1 输出：
Thread-0， i=0 Thread-0， i=1 Thread-0， i=2 Thread-0， i=3 Thread-0， i=4 Thread-0， i=5 Thread-1， i=0 Thread-1， i=1 Thread-1， i=2 Thread-1， i=3 Thread-1， i=4 Thread-1， i=5
DEMO2，synchronized 代码块：
public class Test { private static class Counter { public void count() { synchronized (this) { for (int i=0; i < 6; i++) { System.out.println(Thread.currentThread().getName() + "， i=" + i); } } } } private static class MyThread extends Thread { private Counter mCounter; public MyThread(Counter counter) { mCounter=counter; } @Override public void run() { super.run(); mCounter.count(); } } public static void main(String[] var0) { Counter counter=new Counter(); MyThread myThread1=new MyThread(counter); MyThread myThread2=new MyThread(counter); myThread1.start(); myThread2.start(); } }
DEMO2 输出：
Thread-0， i=0 Thread-0， i=1 Thread-0， i=2 Thread-0， i=3 Thread-0， i=4 Thread-0， i=5 Thread-1， i=0 Thread-1， i=1 Thread-1， i=2 Thread-1， i=3 Thread-1， i=4 Thread-1， i=5
可见，当同步锁未释放时，其他线程将被阻塞，直至获得同步锁。
而且 DEMO1 和 DEMO2 的输出结果是一样的，synchronized 方法 和 synchronized 代码块的不同之处在于 synchronized 方法 作用域较大，作用于整个方法，而 synchronized 代码块 可控制具体的作用域，更精准控制提高效率。（毕竟阻塞的都是时间啊）
DEMO3，仅修改 main 方法：
public static void main(String[] var0) { // 注意：myThread1 和 myThread2 传入的 Counter 是两个不同的对象 MyThread myThread1=new MyThread(new Counter()); MyThread myThread2=new MyThread(new Counter()); myThread1.start(); myThread2.start(); }
DEMO3 输出：
Thread-0， i=0 Thread-1， i=0 Thread-0， i=1 Thread-1， i=1 Thread-1， i=2 Thread-1， i=3 Thread-0， i=2 Thread-1， i=4 Thread-0， i=3 Thread-1， i=5 Thread-0， i=4 Thread-0， i=5
同步锁基于对象，只要锁的来源一致，即可达到同步的作用。所以，但对象不一样，则不能达到同步效果。
特性 2：
当线程 A 调用某对象的synchronized 方法 或者 synchronized 代码块时，若同步锁未释放，其他线程调用同一对象的其他 synchronized 方法 或者 synchronized 代码块时将被阻塞，直至线程 A 释放该对象的同步锁。（注意：重点是其他）
DEMO4，仅修改 doOtherThings 方法的修饰：
public class Test { private static class Counter { public synchronized void count() { System.out.println(Thread.currentThread().getName() + " sleep"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " awake"); } public synchronized void doOtherThings(){ System.out.println(Thread.currentThread().getName() + " doOtherThings"); } } public static void main(String[] var0) { final Counter counter=new Counter(); new Thread(new Runnable() { @Override public void run() { counter.count(); } }).start(); new Thread(new Runnable() { @Override public void run() { counter.doOtherThings(); } }).start(); } }
DEMO4 输出：
Thread-0 sleep Thread-0 awake Thread-1 doOtherThings
可见，synchronized 获得的同步锁并非仅仅锁住代码，而是锁住整个对象。
