摘要：尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問的一個(gè)同步代碼塊或同步方法時(shí)，其他線程對(duì)中所有其它同步代碼塊或同步方法的訪問將被阻塞。同步代碼塊是對(duì)一個(gè)對(duì)象作為參數(shù)進(jìn)行鎖定。

為什么需要同步多線程？
線程的同步是指讓多個(gè)運(yùn)行的線程在一起良好地協(xié)作，達(dá)到讓多線程按要求合理地占用釋放資源。我們采用Java中的同步代碼塊和同步方法達(dá)到這樣的目的。比如這樣的解決多線程無固定序執(zhí)行的問題：

public class TwoThreadTest {
        public static void main(String[] args) {
              Thread th1= new MyThread1();
              Thread th2= new MyThread2();
              th1.start();
              th2.start();
       }
}

class MyThread2 extends Thread{
        @Override
        public void run() {
               for( int i=0;i<10;i++)
                     System. out.println( "thread 1 counter:"+i);
       }
}

class MyThread1 extends Thread{
        @Override
        public void run() {
               for( int i=0;i<10;i++)
                     System. out.println( "thread 2 counter:"+i);
       }      
}

這種狀態(tài)下多線程執(zhí)行的結(jié)果是隨機(jī)地去任意插入執(zhí)行，這完全取決于JVM對(duì)于線程的調(diào)度，在很多要求定序執(zhí)行的情況下，這種隨機(jī)執(zhí)行的狀態(tài)顯然是不合要求的。

public class ThreadTest {
        public static void main(String[] args) {
              MyThread thread = new MyThread();
              Thread th1= new Thread(thread);
              Thread th2= new Thread(thread);
              th1.start();
              th2.start();
       }

}

class MyThread implements Runnable{
        @Override
        public synchronized void run() {
               for( int i=0;i<10;i++)
                     System. out.println(Thread. currentThread().getName()+" counter:"+i);
       }
}

使用了同步方法后我們就可以控制線程獨(dú)占執(zhí)行體對(duì)象，這樣在執(zhí)行的過程中就可以使得線程將執(zhí)行體上的任務(wù)一次性執(zhí)行完后退出鎖定狀態(tài)，JVM再調(diào)度另一個(gè)線程進(jìn)來一次性運(yùn)行執(zhí)行體內(nèi)的任務(wù)。

線程創(chuàng)建運(yùn)行的范式
在以前我們也有自己的線程創(chuàng)建和運(yùn)行的編程范式，一般是定義一個(gè)執(zhí)行類重寫run()方法，但是這種方式將執(zhí)行體和執(zhí)行的任務(wù)放在了一起，從軟件工程的角度來看不利于解耦。一個(gè)線程的執(zhí)行的意思是說線程通過執(zhí)行對(duì)象執(zhí)行了某個(gè)對(duì)象的某個(gè)任務(wù)，從這個(gè)角度來說，將任務(wù)的規(guī)定者從執(zhí)行類中分離出來可以使得多線程編程的各個(gè)角色明晰出來，進(jìn)而獲得良好地解耦，以下就是線程創(chuàng)建和執(zhí)行的編程范式：

public class FormalThreadClass {
        public static void main(String[] args) {
              Thread thread = new Thread( new MyRunnable());
              thread.start();
       }
}

class MyRunnable implements Runnable{
       MyTask myTask = new MyTask();
        @Override
        public void run() {
               myTask.doTask();
       }
}

class MyTask{
        public void doTask() {
              System. out.println( "This is real Tasking");
       }
}

synchronized關(guān)鍵字
synchronized可以用來修飾方法以構(gòu)成同步方法，還可以修飾對(duì)象構(gòu)成同步代碼塊，最終的目的都是一樣的：
給要訪問數(shù)據(jù)的線程添加一個(gè)規(guī)定：一次只允許一個(gè)線程訪問數(shù)據(jù)。只有?當(dāng)前正在訪問數(shù)據(jù)”的線程結(jié)束訪問之后，其他線程才允許訪問這個(gè)數(shù)據(jù)。

關(guān)于synchronized關(guān)鍵字，有以下幾點(diǎn)來說明：

當(dāng)它用來修飾一個(gè)方法或者一個(gè)代碼塊的時(shí)候，能夠保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該段代碼。

當(dāng)兩個(gè)并發(fā)線程訪問同一個(gè)對(duì)象object中的這個(gè)synchronized同步代碼塊或同步方法時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊或同步方法以后才能執(zhí)行該代碼塊或同步方法。

然而，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized同步代碼塊或同步方法時(shí)，另一個(gè)線程仍然可以訪問該object中的非synchronized同步代碼塊或非synchronized同步方法。

尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized同步代碼塊或同步方法時(shí)，其他線程對(duì)object中所有其它synchronized同步代碼塊或同步方法的訪問將被阻塞。

1.以下這個(gè)例子可以說明synchronized方法的這些特性，同步代碼塊也是一樣：

① synchronized方法表面上它只是鎖定了當(dāng)前的方法本身，實(shí)際上當(dāng)synchronized方法起作用的時(shí)候，整個(gè)對(duì)象的帶有synchronized的方法都將被鎖定，這也就是為什么當(dāng)一個(gè)線程執(zhí)行一個(gè)synchronized方法時(shí)，其他的線程除了不能訪問當(dāng)前的同步方法外還并不能訪問其他的同步方法，而只能訪問非synchronized方法，因?yàn)檫@種鎖定是對(duì)象級(jí)別的。

public class ThreadTest {
        public static void main(String[] args) {
               final MyTask myTask = new MyTask();
              Thread thread1 = new Thread( new Runnable() {
                      public void run() {
                           myTask.doTask1();
                     }
              });
              Thread thread2 = new Thread( new Runnable() {
                      public void run() {
                           myTask.doTask2();
                     }
              });
              thread1.start();
              thread2.start();
       }
}

class MyTask{
        public synchronized void doTask1() {
               for ( int i = 0; i < 5; i++) {
                     System. out.println( "1 This is real Tasking "+i);
              }
       }
        public void doTask2() {
               for ( int i = 0; i < 5; i++) {
                     System. out.println( "2 This is real Tasking "+i);
              }
       }
}

② 如使在靜態(tài)方法中用synchronized時(shí)，因?yàn)檫@個(gè)方法就不是僅屬于某個(gè)對(duì)象而是屬于整個(gè)類的了，所以一旦一個(gè)線程進(jìn)入了這個(gè)代碼塊就會(huì)將這個(gè)類的所有對(duì)象的所有synchronized方法或synchronized同步代碼塊鎖定，其他的線程就沒有辦法訪問所有這些對(duì)象的synchronized方法和synchronized代碼塊（注意其他線程還是仍然能訪問這些對(duì)象的非synchronized方法和synchronized代碼塊的），因此這種鎖定是class級(jí)別的。

public class FormalThreadClass {
        public static void main(String[] args) {
              MyTask myTask1 = new MyTask();
              MyTask myTask2 = new MyTask();
              Thread thread1 = new Thread( new MyRunnable(myTask1));
              Thread thread2 = new Thread( new MyRunnable(myTask2));
              thread1.start();
              thread2.start();
       }
}

class MyRunnable implements Runnable {
       MyTask myTask;
        public MyRunnable(MyTask myTask) {
               this. myTask = myTask;
       }
        @Override
        public void run() {
              MyTask. doTask();
       }
}

class MyTask {
        public static synchronized void doTask() {
               for ( int i = 0; i < 5; i++) {
                     System. out.println(Thread. currentThread().getName()+" running "+i);
              }
       }
}

2.synchronized同步代碼塊是對(duì)一個(gè)對(duì)象作為參數(shù)進(jìn)行鎖定。

① 如在使用synchronized(this)時(shí)，一旦一個(gè)線程進(jìn)入了這個(gè)代碼塊就會(huì)將整個(gè)對(duì)象的所有synchronized方法或synchronized同步代碼塊鎖定，其他的線程就沒有辦法訪問這個(gè)對(duì)象的synchronized方法和synchronized代碼塊（注意其他線程還是仍然能訪問這個(gè)對(duì)象的非synchronized方法和synchronized代碼塊的）。

public class ThreadTest {
        public static void main(String[] args) {
               final MyTask myTask = new MyTask();
              Thread thread1 = new Thread( new Runnable() {
                      public void run() {
                           myTask.doTask1();
                     }
              });
              Thread thread2 = new Thread( new Runnable() {
                      public void run() {
                           myTask.doTask2();
                     }
              });
              thread1.start();
              thread2.start();
       }
}

class MyTask {
        public void doTask1() {

               synchronized (this) {
                      for ( int i = 0; i < 5; i++) {
                           System. out.println( "1 is running");
                     }
              }

       }

        public void doTask2() {
               for ( int i = 0; i < 5; i++) {
                     System. out.println( "2 is running");
              }
       }
}

所以：synchronized方法實(shí)際上等同于用一個(gè)synchronized塊包住方法中的所有語句，然后在synchronized塊的括號(hào)中傳入this關(guān)鍵字。當(dāng)然，如果是靜態(tài)方法，需要鎖定的則是class對(duì)象。

① 如在使用synchronized(.class)時(shí)，一旦一個(gè)線程進(jìn)入了這個(gè)代碼塊就會(huì)將整個(gè)類的所有這個(gè)synchronized(.class) 同步代碼塊鎖定，其他的線程就沒有辦法訪問這個(gè)對(duì)象的synchronized(**.class) 代碼塊，這種鎖也是class級(jí)別的，但要注意在這種情況下，其他線程仍然是可以訪問僅做了synchronized的代碼塊或非靜態(tài)方法的，因?yàn)樗鼈儍H僅是對(duì)當(dāng)前對(duì)象的鎖定。

public class FormalThreadClass {
        public static void main(String[] args) {
              MyTask myTask1 = new MyTask();
              MyTask myTask2 = new MyTask();
              Thread thread1 = new Thread( new MyRunnable(myTask1));
              Thread thread2 = new Thread( new MyRunnable(myTask2));
              thread1.start();
              thread2.start();
       }
}

class MyRunnable implements Runnable {
       MyTask myTask;
        public MyRunnable(MyTask myTask) {
               this. myTask = myTask;
       }
        @Override
        public void run() {
               myTask.doTask();
       }
}

class MyTask {
        public  void doTask() {
               synchronized (MyTask.class ) {
                      for ( int i = 0; i < 5; i++) {
                           System. out.println(Thread. currentThread().getName()+" running "+i);
                     }
              }
       }
}

總結(jié)起來這一部分：
synchronized方法是一種粗粒度的并發(fā)控制手段，某一時(shí)刻只能有一個(gè)線程執(zhí)行該方法。synchroized塊則是一種細(xì)粒度的并發(fā)控制，只會(huì)將塊中的代碼同步，位于方法內(nèi)synchroized塊之外的代碼是可以被多個(gè)線程同時(shí)訪問到。