Java之多線程 Atomic（原子的）

一、何謂Atomic？

Atomic一詞跟原子有點關系，后者曾被人認為是最小物質的單位。計算機中的Atomic是指不能分割成若干部分的意思。如果一段代碼被認為是Atomic，則表示這段代碼在執行過程中，是不能被中斷的。通常來說，原子指令由硬件提供，供軟件來實現原子方法（某個線程進入該方法后，就不會被中斷，直到其執行完成）

 

在x86 平台上，CPU提供了在指令執行期間對總線加鎖的手段。CPU芯片上有一條引線#HLOCK pin，如果匯編語言的程序中在一條指令前面加上前綴"LOCK"，經過匯編以后的機器代碼就使CPU在執行這條指令的時候把#HLOCK pin的電位拉低，持續到這條指令結束時放開，從而把總線鎖住，這樣同一總線上別的CPU就暫時不能通過總線訪問內存了，保證了這條指令在多處理器環境中的原子性。

 

二、JDK1.5的原子包：java.util.concurrent.atomic

這個包里面提供了一組原子類。其基本的特性就是在多線程環境下，當有多個線程同時執行這些類的實例包含的方法時，具有排他性，即當某個線程進入方法，執行其中的指令時，不會被其他線程打斷，而別的線程就像自旋鎖一樣，一直等到該方法執行完成，才由JVM從等待隊列中選擇一個另一個線程進入，這只是一種邏輯上的理解。實際上是借助硬件的相關指令來實現的，不會阻塞線程(或者說只是在硬件級別上阻塞了)。其中的類可以分成4組

• AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
• AtomicIntegerArray，AtomicLongArray
• AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
• AtomicMarkableReference，AtomicStampedReference，AtomicReferenceArray

Atomic類的作用

• 使得讓對單一數據的操作，實現了原子化
• 使用Atomic類構建復雜的，無需阻塞的代碼
  • 訪問對2個或2個以上的atomic變量（或者對單個atomic變量進行2次或2次以上的操作）通常認為是需要同步的，以達到讓這些操作能被作為一個原子單元。

2.1 AtomicBoolean , AtomicInteger, AtomicLong, AtomicReference

這四種基本類型用來處理布爾，整數，長整數，對象四種數據。

• 構造函數（兩個構造函數）
  • 默認的構造函數：初始化的數據分別是false，0，0，null
  • 帶參構造函數：參數為初始化的數據
• set( )和get( )方法：可以原子地設定和獲取atomic的數據。類似於volatile，保證數據會在主存中設置或讀取
• getAndSet( )方法
  • 原子的將變量設定為新數據，同時返回先前的舊數據
  • 其本質是get( )操作，然后做set( )操作。盡管這2個操作都是atomic，但是他們合並在一起的時候，就不是atomic。在Java的源程序的級別上，如果不依賴synchronized的機制來完成這個工作，是不可能的。只有依靠native方法才可以。
• compareAndSet( ) 和weakCompareAndSet( )方法
  • 這兩個方法都是conditional modifier方法。這2個方法接受2個參數，一個是期望數據(expected)，一個是新數據(new)；如果atomic里面的數據和期望數據一致，則將新數據設定給atomic的數據，返回true，表明成功；否則就不設定，並返回false。
• 對於AtomicInteger、AtomicLong還提供了一些特別的方法。getAndIncrement( )、incrementAndGet( )、getAndDecrement( )、decrementAndGet ( )、addAndGet( )、getAndAdd( )以實現一些加法，減法原子操作。(注意 --i、++i不是原子操作，其中包含有3個操作步驟：第一步，讀取i；第二步，加1或減1；第三步：寫回內存)

2.1.1 1個例子-使用AtomicReference創建線程安全的堆棧

public class LinkedStack<T> {

    private AtomicReference<Node<T>> stacks = new AtomicReference<Node<T>>();

    public T push(T e) {
        Node<T> oldNode, newNode;
        while (true) { //這里的處理非常的特別，也是必須如此的。
            oldNode = stacks.get();
            newNode = new Node<T>(e, oldNode);
            if (stacks.compareAndSet(oldNode, newNode)) {
                return e;
            }
        }
    }
    
    public T pop() {
        Node<T> oldNode, newNode;
        while (true) {
            oldNode = stacks.get();
            newNode = oldNode.next;
            if (stacks.compareAndSet(oldNode, newNode)) {
                return oldNode.object;
            }
        }
    }

    private static final class Node<T> {
        private T object;
        
        private Node<T> next;

        private Node(T object, Node<T> next) {
            this.object = object;
            this.next = next;
        }
    }
}

2.1.2 幾個問題

Q1： compareAndSet和weakCompareAndSet的區別？

A1： 有人認為這是個坑，因為這2個方法其中的內容是一模一樣的。疑惑ing（環境JDK1.6.0_20_b02）

 

Q2：volatile boolean和AtomicBoolean的區別？

 

Q3：volatile int和AtomicInteger的區別？

 

Q4：LazySet()和Set()的區別？

 

三、Atomic舉例

3.1 原子量實現的計數器

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {

    private AtomicInteger value = new AtomicInteger();

    public int getValue() {
        return value.get();
    }

    public int increase() {
        return value.incrementAndGet();// 內部使用死循環for(;;)調用compareAndSet(current, next)
        //        return value.getAndIncrement();
    }

    public int increase(int i) {
        return value.addAndGet(i);// 內部使用死循環for(;;)調用compareAndSet(current, next)
        //        return value.getAndAdd(i);
    }

    public int decrease() {
        return value.decrementAndGet();// 內部使用死循環for(;;)調用compareAndSet(current, next)
        //        return value.getAndDecrement();
    }

    public int decrease(int i) {
        return value.addAndGet(-i);// 內部使用死循環for(;;)調用compareAndSet(current, next)
        //        return value.addAndGet(-i);
    }

    public static void main(String[] args) {
        final AtomicCounter counter = new AtomicCounter();
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(counter.increase());
                }
            });
        }
        service.shutdown();
    }
}

3.2 原子量實現的銀行取款

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
public class Account {

    private AtomicLong balance;

    public Account(long money) {
        balance = new AtomicLong(money);
        System.out.println("Total Money:" + balance);
    }

    public void deposit(long money) {
        balance.addAndGet(money);
    }

    public void withdraw(long money) {
        for (; ; ) {//保證即時同一時間有人也在取款也可以再次嘗試取款，如果不需要並發嘗試取款，可以去掉這句
            long oldValue = balance.get();
            if (oldValue < money) {
                System.out.println(Thread.currentThread().getName() + " 余額不足！ 余額：" + balance);
                break;
            }
            try {Thread.sleep(new Random().nextInt(1000));} catch (Exception e) { }// 模擬取款時間
            if (balance.compareAndSet(oldValue, oldValue - money)) {
                System.out.println(Thread.currentThread().getName() + " 取款 " + money + " 成功！ 余額：" + balance);
                break;
            }
            System.out.println(Thread.currentThread().getName() + " 遇到並發，再次嘗試取款！");
        }
    }

    public static void main(String[] args) {
        final Account account = new Account(1000);
        ExecutorService pool = Executors.newCachedThreadPool();
        int i = 0;
        while (i++ < 13) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    account.withdraw(100);
                }
            });
        }
        pool.shutdown();
    }
}