摘要：共享資源臨界資源修飾實例方法輸出結果上述代碼與前面不同的是我們同時創建了兩個新實例，然后啟動兩個不同的線程對共享變量進行操作，但很遺憾操作結果是而不是期望結果。

線程安全是并發編程中的重要關注點，應該注意到的是，造成線程安全問題的主要誘因有兩點

一是存在共享數據(也稱臨界資源)

二是存在多條線程共同操作共享數據

因此為了解決這個問題，我們可能需要這樣一個方案，當存在多個線程操作共享數據時，需要保證同一時刻有且只有一個線程在操作共享數據，其他線程必須等到該線程處理完數據后再進行，這種方式有個高尚的名稱叫互斥鎖，即能達到互斥訪問目的的鎖，也就是說當一個共享數據被當前正在訪問的線程加上互斥鎖后，在同一個時刻，其他線程只能處于等待的狀態，直到當前線程處理完畢釋放該鎖。
在 Java 中，關鍵字 synchronized 可以保證在同一個時刻，只有一個線程可以執行某個方法或者某個代碼塊(主要是對方法或者代碼塊中存在共享數據的操作)，同時我們還應該注意到synchronized另外一個重要的作用，synchronized可保證一個線程的變化(主要是共享數據的變化)被其他線程所看到（保證可見性，完全可以替代Volatile功能），這點確實也是很重要的。

synchronized關鍵字最主要有以下3種應用方式，下面分別介紹

修飾實例方法，作用于當前實例加鎖，進入同步代碼前要獲得 當前實例 的鎖

修飾靜態方法，作用于當前類對象加鎖，進入同步代碼前要獲得 當前類對象 的鎖

修飾代碼塊，指定加鎖對象，對給定對象加鎖，進入同步代碼庫前要獲得 給定對象 的鎖。

所謂的實例對象鎖就是用synchronized修飾實例對象中的實例方法，注意是實例方法不包括靜態方法

package sychronized;

import static net.mindview.util.Print.*;

import java.util.concurrent.*;

public class AccountingSync2 implements Runnable {
    //共享資源(臨界資源)
    static int i = 0;

    /**
     * synchronized 修飾實例方法
     */
    synchronized void getI() {
        if (i % 1000000 == 0) {
            print(i);
        }
    }

    public synchronized void increase() {
        i++;
        getI();
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        print(i);
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        AccountingSync2 accountingSync2 = new AccountingSync2();
        exec.execute(accountingSync2);
        exec.execute(accountingSync2);
        exec.shutdown();
    }
}

最后的結果為：
1000000
1519541
2000000
2000000

上述代碼中，我們開啟兩個線程操作同一個共享資源即變量i，由于i++操作并不具備原子性，該操作是先讀取值，然后寫回一個新值，相當于原來的值加上1，分兩步完成，如果第二個線程在第一個線程讀取舊值和寫回新值期間讀取i的域值，那么第二個線程就會與第一個線程一起看到同一個值，并執行相同值的加1操作，這也就造成了線程安全失敗，因此對于increase方法必須使用synchronized修飾，以便保證線程安全。

此時注意到synchronized修飾的是實例方法increase，在這樣的情況下，當前線程的鎖便是實例對象instance，注意Java中的線程同步鎖可以是任意對象。

當一個線程正在訪問一個對象的 synchronized 實例方法，那么其他線程不能訪問該對象的其他 synchronized 方法，畢竟一個對象只有一把鎖，當一個線程獲取了該對象的鎖之后，其他線程無法獲取該對象的鎖，所以無法訪問該對象的其他synchronized實例方法，但是其他線程還是可以訪問該實例對象的其他非synchronized方法，但是一個 synchronized 方法可以調用另一個需要獲得同樣鎖的synchronized方法，因為已經獲取了鎖。

如果是一個線程 A 需要訪問實例對象 obj1 的 synchronized 方法 f1(當前對象鎖是obj1)，另一個線程 B 需要訪問實例對象 obj2 的 synchronized 方法f2(當前對象鎖是obj2)，這樣是允許的，因為兩個實例對象鎖并不同相同，此時如果兩個線程操作數據并非共享的，線程安全是有保障的，遺憾的是如果兩個線程操作的是共享數據，那么線程安全就有可能無法保證了。

package sychronized;

import static net.mindview.util.Print.*;
import java.util.concurrent.*;

public class AccountingSync2 implements Runnable {
    //共享資源(臨界資源)
    static int i = 0;

    /**
     * synchronized 修飾實例方法
     */
    synchronized void getI() {
        if (i % 1000000 == 0) {
            print(i);
        }
    }

    public synchronized void increase() {
        i++;
        getI();
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        print(i);
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        AccountingSync2 accountingSync2 = new AccountingSync2();
        exec.execute(accountingSync2);
        exec.execute(new AccountingSync2());
        exec.shutdown();
    }
}

#輸出結果：
1000000
1249050
1329218

上述代碼與前面不同的是我們同時創建了兩個新實例AccountingSync2，然后啟動兩個不同的線程對共享變量i進行操作，但很遺憾操作結果是1329218而不是期望結果2000000。

雖然我們使用synchronized修飾了increase方法，但卻new了兩個不同的實例對象，這也就意味著存在著兩個不同的實例對象鎖，因此兩個進程都會進入各自持有對象的對象鎖，也就是說兩個線程使用的是不同的鎖，因此線程安全是無法保證的。

解決這種困境的的方式是將synchronized作用于靜態的increase方法，這樣的話，對象鎖就當前類對象，由于無論創建多少個實例對象，但對于的類對象擁有只有一個，所有在這樣的情況下對象鎖就是唯一的。下面我們看看如何使用將synchronized作用于靜態的increase方法。

當synchronized作用于靜態方法時，其鎖就是當前類的class對象鎖。由于靜態成員不專屬于任何一個實例對象，是類成員，因此通過class對象鎖可以控制靜態成員的并發操作。需要注意的是如果一個線程A調用一個實例對象的非static synchronized 方法，而線程B需要調用這個實例對象所屬類的靜態 synchronized方法，是允許的，不會發生互斥現象，因為訪問靜態 synchronized 方法占用的鎖是當前類的 class 對象，而訪問非靜態 synchronized 方法占用的鎖是當前實例對象鎖。

package sychronized;

import static net.mindview.util.Print.*;
import java.util.concurrent.*;

class OtherTask implements Runnable{
    AccountingSyncClass accounting = new AccountingSyncClass();
    @Override
    public void run(){
        for (int j = 0; j < 1000000; j++) {
            accounting.increaseForObject();
        }
        print(accounting.getI());
    }
}

public class AccountingSyncClass implements Runnable {
    //共享資源(臨界資源)
    private static int i = 0;

    /**
     * synchronized 修飾實例方法
     */
    public synchronized void increaseForObject() {
        i++;
    }

    public synchronized static void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        print(i);
    }
    
    public int getI(){
        return i;
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new AccountingSyncClass());
        exec.execute(new AccountingSyncClass());
        exec.execute(new OtherTask()); // 1
        exec.shutdown();
    }
}

輸出結果為：
1459696
2692181
2754098

注釋掉代碼中的 1 那一行代碼的輸出結果為：
1468495
2000000

由于synchronized關鍵字修飾的是靜態increase方法，與修飾實例方法不同的是，其鎖對象是當前類的class對象。

注意代碼中的increase4Obj方法是實例方法，其對象鎖是當前實例對象，如果別的線程調用該方法，將不會產生互斥現象，畢竟鎖對象不同，但我們應該意識到這種情況下可能會發現線程安全問題(操作了共享靜態變量i)。

因此在設計同步代碼的時候一定要仔細思考到底該用 多大的同步粒度 和 該對什么對象 使用同步操作。

除了使用關鍵字修飾實例方法和靜態方法外，還可以使用同步代碼塊，在某些情況下，我們編寫的方法體可能比較大，同時存在一些比較耗時的操作，而需要同步的代碼又只有一小部分，如果直接對整個方法進行同步操作，可能會得不償失，此時我們可以使用同步代碼塊的方式對需要同步的代碼進行包裹，這樣就無需對整個方法進行同步操作了。

public class AccountingSync implements Runnable{
    static AccountingSync instance=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗時操作....
        //使用同步代碼塊對變量i進行同步操作,鎖對象為instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

從代碼看出，將synchronized作用于一個給定的實例對象instance，即當前實例對象就是鎖對象，每次當線程進入synchronized包裹的代碼塊時就會要求當前線程持有instance實例對象鎖。

如果當前有其他線程正持有該對象鎖，那么新到的線程就必須等待，這樣也就保證了每次只有一個線程執行i++操作。

當然除了instance作為對象外，我們還可以使用this對象(代表當前實例)或者當前類的class對象作為鎖。

//this,當前實例對象鎖
synchronized(this){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

//class對象鎖
synchronized(AccountingSync.class){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

package sychronized;

import static net.mindview.util.Print.*;
import java.util.concurrent.*;

class OtherTask implements Runnable{
    AccountingSyncClass accounting = new AccountingSyncClass();
    @Override
    public void run(){
        for (int j = 0; j < 1000000; j++) {
            accounting.increaseForObject();
        }
        print(accounting.getAdapterInteger());
    }
}

class AdapterInteger {
    private int i = 0;
    public synchronized void increase(){
        ++i;
    }
    public synchronized int getI(){
        return i;
    }
}

public class AccountingSyncClass implements Runnable {
    //共享資源(臨界資源)
    private static AdapterInteger adapterInteger = new AdapterInteger();

    /**
     * synchronized 修飾實例方法
     */
    public synchronized void increaseForObject() {
        adapterInteger.increase();
    }

    public synchronized static void increase() {
        adapterInteger.increase();
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
        print(getAdapterInteger());
    }

    public static int getAdapterInteger() {
        return adapterInteger.getI();
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new AccountingSyncClass());
        exec.execute(new AccountingSyncClass());
        exec.execute(new OtherTask());
        exec.shutdown();
    }
}

#輸出結果為
1183139
2688189
3000000

這樣三個線程中的任務的鎖都是我們的共享變量 adapterInteger 對象的鎖，這樣就可以完成真正的同步，不管哪個線程都是獲得了 adapterInteger 對象的鎖才能運行相應的代碼。