判定規則：

如果一個類中存在變數，並且此變數的操作不是原子操作，那麼這個類就是非執行緒安全的類。線上程產生競爭條件的情況下，多執行緒訪問導致原子性不可保證。

競爭條件產生的原因：

當計算的正確性依賴於執行時中相關的時序或多執行緒的交替時，會產生競爭條件。多執行緒情況下，執行緒的時序不能確定，所以一旦程式依賴於特定的執行時序就會產生競爭條件。所以，在多執行緒環境下必須保證執行緒的可見性可控或避免產生競爭條件。記憶體可見性，可以理解為變數是否對外可訪問，是否受保護。執行緒之間出現競爭，是因為業務依賴於時序操作或變數的可見性未加以約束。一般如果要實現記憶體可見性控制有兩種方法，即使用synchronized和volatile關鍵字。

class SafetyWithSynchronized{

    private int something = 0;

    public synchronized  int getSomething ( ) {
        return something;
    }

    public synchronized  void setSomething (int something) {
        this.something = something;
    }
}

class SafetyWithVolatile{
   private volatile int something = 0;

   public int getSomething ( ) {
        return something;
   }
   public void setSomething (int something) {
        this.something = something;
   }
}
 

使用volatile 關鍵字的方案，在效能上要好很多，因為volatile是一個輕量級的同步，只能保證多執行緒的記憶體可見性，不能保證多執行緒的執行有序性。因此開銷遠比synchronized要小。Volatile 變數具有 synchronized 的可見性特性，但是不具備原子特性。這就是說執行緒能夠自動發現 volatile 變數的最新值。Volatile 變數可用於提供執行緒安全，但是隻能應用於非常有限的一組用例：多個變數之間或者某個變數的當前值與修改後值之間沒有約束。出於簡易性或可伸縮性的考慮，大多數情況下可能傾向於使用 volatile 變數而不是鎖。當使用 volatile 變數而非鎖時，某些習慣用法（idiom）更加易於編碼和閱讀。此外，volatile 變數不會像鎖那樣造成執行緒阻塞，因此也很少造成可伸縮性問題。在某些情況下，如果讀操作遠遠大於寫操作，volatile 變數還可以提供優於鎖的效能優勢。

CAS原理實現原子操作：

原子操作：

在複雜的業務處理中，假設有操作A和B。若果從執行A的執行緒看，當其它執行緒執行B時，要麼B全部執行完成，要麼一點都沒有執行，這樣A和B互為原子操作。一個原子操作是指：該操作對於所有的操作，包括它自己，都滿足前面描述的狀態。

CAS 指的是現代 CPU 廣泛支援的一種對記憶體中的共享資料進行操作的一種特殊指令。這個指令會對記憶體中的共享資料做原子的讀寫操作。簡單介紹一下這個指令的操作過程：首先，CPU 會將記憶體中將要被更改的資料與期望的值做比較。然後，當這兩個值相等時，CPU 才會將記憶體中的數值替換為新的值。否則便不做操作。最後，CPU 會將舊的數值返回。這一系列的操作是原子的。它們雖然看似複雜，但卻是 Java 5 併發機制優於原有鎖機制的根本。簡單來說，CAS 的含義是“我認為原有的值應該是什麼，如果是，則將原有的值更新為新值，否則不做修改，並告訴我原來的值是多少”。（這段描述引自《Java併發程式設計實踐》）

java.util.concurrent併發包實現原子操作：

由於java的CAS同時具有 volatile 讀和volatile寫的記憶體語義，因此Java執行緒之間的通訊現在有了下面四種方式：

1. A執行緒寫volatile變數，隨後B執行緒讀這個volatile變數。
2. A執行緒寫volatile變數，隨後B執行緒用CAS更新這個volatile變數。
3. A執行緒用CAS更新一個volatile變數，隨後B執行緒用CAS更新這個volatile變數。
4. A執行緒用CAS更新一個volatile變數，隨後B執行緒讀這個volatile變數。

Java的CAS會使用現代處理器上提供的高效機器級別原子指令，這些原子指令以原子方式對記憶體執行讀-改-寫操作，這是在多處理器中實現同步的關鍵（從本質上來說，能夠支援原子性讀-改-寫指令的計算機器，是順序計算圖靈機的非同步等價機器，因此任何現代的多處理器都會去支援某種能對記憶體執行原子性讀-改-寫操作的原子指令）。同時，volatile變數的讀/寫和CAS可以實現執行緒之間的通訊。把這些特性整合在一起，就形成了整個concurrent包得以實現的基石。如果我們仔細分析concurrent包的原始碼實現，會發現一個通用化的實現模式：

1. 首先，宣告共享變數為volatile；
2. 然後，使用CAS的原子條件更新來實現執行緒之間的同步；
3. 同時，配合以volatile的讀/寫和CAS所具有的volatile讀和寫的記憶體語義來實現執行緒之間的通訊。

常見原子變數：

在java.util.concurrent.atomic包下還有很多類，使用這些類可以保證對這些類的諸如“獲取-更新”操作是原子性的，從而避發生競爭條件。jdk1.7 java.util.concurrent.atomic的原子變數：

AtomicBoolean 	//A boolean value that may be updated atomically.
AtomicInteger 	//An int value that may be updated atomically.
AtomicIntegerArray 	//An int array in which elements may be updated atomically.
AtomicIntegerFieldUpdater<T> 	//A reflection-based utility that enables atomic updates to designated volatile int fields of designated classes.
AtomicLong 	//A long value that may be updated atomically.
AtomicLongArray 	//A long array in which elements may be updated atomically.
AtomicLongFieldUpdater<T> 	//A reflection-based utility that enables atomic updates to designated volatile long fields of designated classes.
AtomicMarkableReference<V> 	//An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.
AtomicReference<V> 	//An object reference that may be updated atomically.
AtomicReferenceArray<E> 	//An array of object references in which elements may be updated atomically.
AtomicReferenceFieldUpdater<T,V> 	//A reflection-based utility that enables atomic updates to designated volatile reference fields of designated classes.
AtomicStampedReference<V> 	//An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.

注：學習併發程式設計的時候儘可能地通過二手資料去發掘一手資料，這樣可以學到更多，最好是從Java API中去尋找。

非執行緒安全示例：

package net.jcip.examples;

import java.math.BigInteger;
import javax.servlet.*;

import net.jcip.annotations.*;

/**
 * UnsafeCountingFactorizer
 *
 * Servlet that counts requests without the necessary synchronization
 *
 * @author Brian Goetz and Tim Peierls
 */
@NotThreadSafe
public class UnsafeCountingFactorizer extends GenericServlet implements Servlet {
    private long count = 0;

    public long getCount() {
        return count;
    }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        ++count;
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse res, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[] { i };
    }
}

注：此類在單執行緒環境中可以很好的執行，但是在多執行緒環境中就是不是執行緒安全的了，因為++count不是原子操作。

執行緒安全示例：

package net.jcip.examples;

import java.math.BigInteger;
import java.util.concurrent.atomic.*;
import javax.servlet.*;

import net.jcip.annotations.*;

/**
 * CountingFactorizer
 *
 * Servlet that counts requests using AtomicLong
 *
 * @author Brian Goetz and Tim Peierls
 */
@ThreadSafe
public class CountingFactorizer extends GenericServlet implements Servlet {
    private final AtomicLong count = new AtomicLong(0);

    public long getCount() { return count.get(); }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        count.incrementAndGet();
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse res, BigInteger[] factors) {}
    BigInteger extractFromRequest(ServletRequest req) {return null; }
    BigInteger[] factor(BigInteger i) { return null; }
}

利用原子變數實現簡單的自增序列例項：

class Sequencer {
   private final AtomicLong sequenceNumber= new AtomicLong(0);

  public long next() {
     return sequenceNumber.getAndIncrement();
   }
 }

對原子變數操作的總結：

1. 知道++操作不是原子操作。

2. 非原子操作有執行緒安全問題。

3. 併發下的記憶體可見性可以通過synchronized和volatile加以控制。

4. Atomic類通過CAS + volatile可以比synchronized做的更高效，推薦使用。

5.利用AtomicLong這樣已有的執行緒安全管理類的狀態是非常實用的，相比於非執行緒安全物件，判斷一個執行緒安全物件的可能狀態和狀態的裝換要容易得多。這簡化了維護和驗證執行緒安全性的工作。