共享變數 （Volatile Atomic）

volatile:當多個執行緒訪問一個成員變數的時候，需要這個變數在多個執行緒中可見。

Atomic:Atomic方法對該變數的操作是原子性操作，顆粒度是到對這個變數的一次操作。

private static  AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();

Atomic+synchronized ：如果要保證多執行緒之間的原子性操作，也就是對一個變數進行多次Atomic方法操縱操作。那就需要加synchronized ，來 保證多執行緒間的原子性。

private static  AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();
count.incrementAndGet();
count.incrementAndGet();
//多執行緒間他們不是原子性操作，如果需要原子性操作，需要在外層方法加synchronized

Volatile

原理：當執行緒操作該變數的時候會強制去主記憶體（堆）中去讀取。使用方法如下

public class RunThread extends Thread{
    private volatile boolean
 
 isRunning = true;

    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }

    public void run(){
        System.out.println("進入run方法..");
        int i = 0;
        while(isRunning == true){
            //..
        }
        System.out.println("執行緒停止");
    }

    public
 
 static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(1000);
        rt.setRunning(false);
        System.out.println("isRunning的值已經被設定了false");
    }
}

volatile 變數本身不具備原子性。說明

public class VolatileNoAtomic extends Thread{
    private static volatile int count;
    private static void addCount(){
        for (int i = 0; i < 1000; i++) {
            //count++ ;
            count.incrementAndGet();
        }
        System.out.println(count);
    }

    public void run(){
        addCount();
    }

    public static void main(String[] args) {

        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }

        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }

Atomic

如果要實現原子性（同步），可以使用Atomic型別的變數。如AtomicInteger、AtomicLong…

private static AtomicInteger count = new AtomicInteger(0);

但是，只能保證方法的原子性，不能保證多執行緒間的原子性。解決方法可以給方法synchronized 修飾，加說明

private static AtomicInteger count = new AtomicInteger(0);

    //多個addAndGet在一個方法內是非原子性的，需要加synchronized進行修飾，保證4個addAndGet整體原子性
    /**synchronized*/
    public synchronized int multiAdd(){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count.addAndGet(1);
            count.addAndGet(2);
            count.addAndGet(3);
            count.addAndGet(4); //+10
            return count.get();
    }


    public static void main(String[] args) {

        final AtomicUse au = new AtomicUse();

        List<Thread> ts = new ArrayList<Thread>();
        for (int i = 0; i < 100; i++) {
            ts.add(new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(au.multiAdd());
                }
            }));
        }

        for(Thread t : ts){
            t.start();
        }

ThreadLocal

當使用ThreadLocal維護變數時，ThreadLocal為每個使用該變數的執行緒提供獨立的變數副本，所以每一個執行緒都可以獨立地改變自己的副本，而不會影響其它執行緒所對應的副本。用ThreadLocal可以一定程度減少鎖競爭。使用方式如下

public class ConnThreadLocal {

    public static ThreadLocal<String> th = new ThreadLocal<String>();

    public void setTh(String value){
        th.set(value);
    }
    public void getTh(){
        System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
    }

    public static void main(String[] args) throws InterruptedException {

        final ConnThreadLocal ct = new ConnThreadLocal();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ct.setTh("張三");
                ct.getTh();
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    ct.getTh();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t1.start();
        t2.start();
    }

}