構建執行緒安全的共享物件，使其在多執行緒環境下能夠提供安全的訪問。編寫正確的併發程式關鍵在於控制共享、可變的狀態進行訪問管理。synchornized關鍵字既可以阻塞程式，也可以維護操作的原子性，它是一個執行緒安全與非執行緒安全的臨界區標識，通過它我們可以控制物件的記憶體可見性。不得不提到volatile，volatile僅僅是控制可見性，而同步性卻不及synchornized。

多執行緒訪問共享變數的詭異結果：

package net.jcip.examples;

/**
 * NoVisibility
 * <p/>
 * Sharing variables without synchronization
 *
 * @author Brian Goetz and Tim Peierls
 */

public class NoVisibility {
    private static boolean ready;
    private static int number;

    private static class ReaderThread extends Thread {
        public void run() {
            while (!ready)
                Thread.yield();
            System.out.println(number);
        }
    }

    public static void main(String[] args) {
        new ReaderThread().start();
        number = 42;
        ready = true;
    }
}
 

static的變數意味著，在記憶體中它是一個公用變數；在多執行緒中，這裡輸出的結果是難於預估的，可能是42也可能是0，甚至執行緒不停止；因為這裡沒用使用任何的同步機制加以控制。處理方法是：需要跨執行緒的變數，需要加入恰當的同步。

解決多執行緒同步的可見性問題：

鎖不僅僅是關於同步與互斥的，也是關於記憶體可見的。為了保證所有執行緒都能夠看到共享的、可變變數的最新值，讀取和寫入必須使用公共的鎖進行同步。根據上述多執行緒詭異問題，下面來加入適當的同步：

package net.jcip.examples;

/**
 * NoVisibility
 * <p/>
 * Sharing variables without synchronization
 *
 * @author Brian Goetz and Tim Peierls
 */

public class NoVisibility {
	private static boolean ready;
	private static int number;

	private static class ReaderThread extends Thread {
		public void run() {
			synchronized (NoVisibility.class) {
				while (!ready)
					Thread.yield();

				System.out.println(this.getName() + number);
			}
		}
	}

	public static void resetValue(boolean ready, int number) {
		synchronized (NoVisibility.class) {
			NoVisibility.number = number;
			NoVisibility.ready = ready;
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 200; i++) {
			Thread thread = new ReaderThread();
			thread.setName("THREAD:"+i + "---");
			thread.start();
			NoVisibility.resetValue(true, i);
		}
	}
}
 

最簡單的改法是將變數的可見性改了，使用volatile關鍵字（這裡不推薦，請看程式碼後面的注意）：

package net.jcip.examples;

/**
 * NoVisibility
 * <p/>
 * Sharing variables without synchronization
 *
 * @author Brian Goetz and Tim Peierls
 */

public class NoVisibility {
	private static volatile boolean ready;
	private static volatile int number;

	private static class ReaderThread extends Thread {
		public void run() {
			while (!ready)
				Thread.yield();
			System.out.println(this.getName() + number);
		}
	}

	public static void resetValue(boolean ready, int number) {
		NoVisibility.number = number;
		NoVisibility.ready = ready;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 200; i++) {
			Thread thread = new ReaderThread();
			thread.setName("THREAD:"+i + "---");
			thread.start();
			NoVisibility.resetValue(true, i);
		}
	}
}
 

注意：只有當volatile變數能夠簡化實現和同步策略的驗證時，才使用它們。當驗證正確性必須推斷可見性問題時，應當避免使用volatile變數。正確使用volatile變數的方式包括：用於確保它們所引用物件的狀態的可見性，或者用於標識重要的生命週期事件的發生（如，狀態：啟用、關閉）。加鎖可以保證可見性和原子性，volatile只能保證可見性。

Volatile變數使用的條件：

1.寫入變數不依賴於當前值；或者確保只有單一執行緒在修改該值；

2、變數不需要與其他狀態參與不變約束；

3、訪問變數時，沒有其他原因需要加鎖；

多執行緒訪問造成過期資料問題：

當一個執行緒在沒有同步的情況下讀取變數，它可能會得到一個過期值。還是上面那段程式碼中的例子。在多執行緒中，可能ready在其它執行緒中的值還未被修改。所以很有可能ready=false;如果在多執行緒中處理業務，那麼變數的狀態將是資料出錯的致命元凶。有時候資料不能快速地實現同步並不傷大雅，但是是以犧牲體驗效果為代價的。如果我們多個指令在更新裝置的GPS位置，可能偏差不是很大，但是效果不佳是顯而易見的。來看個例子：

package net.jcip.examples;

import net.jcip.annotations.*;

/**
 * MutableInteger
 * <p/>
 * Non-thread-safe mutable integer holder
 *
 * @author Brian Goetz and Tim Peierls
 */

@NotThreadSafe
public class MutableInteger {
    private int value;

    public int get() {
        return value;
    }

    public void set(int value) {
        this.value = value;
    }
}

將其修改為執行緒安全類的做法，為getter、setter加synchronized同步關鍵字：

package net.jcip.examples;

import net.jcip.annotations.*;

/**
 * SynchronizedInteger
 * <p/>
 * Thread-safe mutable integer holder
 *
 * @author Brian Goetz and Tim Peierls
 */
@ThreadSafe
public class SynchronizedInteger {
    @GuardedBy("this") private int value;

    public synchronized int get() {
        return value;
    }

    public synchronized void set(int value) {
        this.value = value;
    }
}

注：getter也需要同步，否則不能保證其他執行緒讀取到的value是最新的。

安全地釋出物件：

釋出物件 實際上就是擴大物件提供訪問範圍，如public的屬性和方法。安全釋出物件的目的是：維護物件的封裝性和不可變性，防止不正當地使用物件。下面來看一個物件釋出示例：

package net.jcip.examples;

import java.util.*;

/**
 * Secrets
 *
 * Publishing an object
 *
 * @author Brian Goetz and Tim Peierls
 */
class Secrets {
    public static Set<Secret> knownSecrets;

    public void initialize() {
        knownSecrets = new HashSet<Secret>();
    }
}


class Secret {
}

最常見的釋出物件就是將物件儲存到靜態變數中提供訪問。上面initialize方法例項化儲存物件到knownSecrets的引用，將Secret物件新增到knownSecrets就是一個釋出物件的操作。釋出物件，可以說就是提供物件對外訪問的入口。它可以是一個私有屬性提供共有方法的訪問，這也實現了物件的釋出。但是，下面的示例不推薦大家這樣寫：

package net.jcip.examples;

/**
 * UnsafeStates
 * <p/>
 * Allowing internal mutable state to escape
 *
 * @author Brian Goetz and Tim Peierls
 */
class UnsafeStates {
    private String[] states = new String[]{
        "AK", "AL" /*...*/
    };

    public String[] getStates() {
        return states;
    }
}

雖然我們可以獲取到狀態名稱，但是我們不知道對於使用getStates()方法的執行緒將如何使用它，這是一個執行緒引用的安全問題。所以，封裝使得程式的正確性分析更可行，而且不容易偶然地破壞設計約束。

將物件封裝好了再發布：

使用一個未完全封裝的物件，就破壞了程式的封裝性。不要讓this構造在構造期間逸出。來看下面一個例子：

package net.jcip.examples;

/**
 * ThisEscape
 * <p/>
 * Implicitly allowing the this reference to escape
 *
 * @author Brian Goetz and Tim Peierls
 */
public class ThisEscape {
    public ThisEscape(EventSource source) {
        source.registerListener(new EventListener() {
            public void onEvent(Event e) {
                doSomething(e);
            }
        });
    }

    void doSomething(Event e) {
    }


    interface EventSource {
        void registerListener(EventListener e);
    }

    interface EventListener {
        void onEvent(Event e);
    }

    interface Event {
    }
}

此處的建構函式存在方法的重寫，source.registerListener的實現就是不安全的物件釋出，因為在釋出期間呼叫了registerListener方法。

修正方法：使用工廠方法防止this引用在構造期間逸出。示例如下：

package net.jcip.examples;

/**
 * SafeListener
 * <p/>
 * Using a factory method to prevent the this reference from escaping during construction
 *
 * @author Brian Goetz and Tim Peierls
 */
public class SafeListener {
    private final EventListener listener;

    private SafeListener() {
        listener = new EventListener() {
            public void onEvent(Event e) {
                doSomething(e);
            }
        };
    }

    public static SafeListener newInstance(EventSource source) {
        SafeListener safe = new SafeListener();
        source.registerListener(safe.listener);
        return safe;
    }

    void doSomething(Event e) {
    }


    interface EventSource {
        void registerListener(EventListener e);
    }

    interface EventListener {
        void onEvent(Event e);
    }

    interface Event {
    }
}

只要在初始化期間不要進行業務處理就可以實現執行緒安全了，即通過其他方法來啟動執行緒的呼叫。

安全地共享物件：

在併發程式中，使用和共享物件的一些最有效的策略如下：

-------------執行緒限制：--------------

一個執行緒限制的物件，通過限制線上程中，而被執行緒獨佔，且只能被佔有它的執行緒修改。

-------------共享只讀(read-only)：-------------

一個共享的只讀物件，在沒有額外同步的情況下，可以被多個執行緒併發地訪問，但任何執行緒都不能修改它。共享只讀物件包括可變物件與高效不可變物件。

-------------共享執行緒安全(thread-safe)：-------------

一個執行緒安全的物件在內部進行同步，所以其它執行緒無額外同步，就可以通過公共介面隨意地訪問它。

-------------被守護（Guarded）：-------------

一個被守護的物件只能通過特定的鎖來訪問。被守護的物件包括哪些被執行緒安全物件封裝的物件，和已知特定的鎖保護起來的已釋出物件。