線程安全和線程同步Synchronized

部分轉載：
線程安全：http://blog.csdn.net/ghevinn/article/details/37764791
Synchronized: http://blog.csdn.net/ghsau/article/details/7421217
Volatile:http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程纔可使用。不會出現數據不一致或者數據污染。
線程不安全就是不提供數據訪問保護，有可能出現多個線程先後更改數據造成所得到的數據是髒數據

1. 概念

如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。
或者說，一個類或者程序所提供的接口對於線程來說是原子操作或者多個線程之間的切換不會導致該接口的執行結果存在二義性,也就是說我們不用考慮同步的問題。
線程安全問題都是由全局變量及靜態變量引起的。(這句還未考證，但對全局變量和靜態變量操作在多線程模型中會引發線程不安全)
若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執行寫操作，一般都需要考慮線程同步，否則的話就可能影響線程安全。

2. 安全性

比如一個 ArrayList 類，在添加一個元素的時候，它可能會有兩步來完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。
在單線程運行的情況下，如果 Size = 0，添加一個元素後，此元素在位置 0，而且 Size=1；
而如果是在多線程情況下，比如有兩個線程，線程 A 先將元素存放在位置 0。但是此時 CPU 調度線程A暫停，線程 B 得到運行的機會。線程B也向此 ArrayList 添加元素，因爲此時 Size 仍然等於 0 （注意哦，我們假設的是添加一個元素是要兩個步驟哦，而線程A僅僅完成了步驟1），所以線程B也將元素存放在位置0。然後線程A和線程B都繼續運行，都增加 Size 的值。
那好，我們來看看 ArrayList 的情況，元素實際上只有一個，存放在位置 0，而 Size 卻等於 2。這就是“線程不安全”了。

3. 線程同步

3.1 Synchronized(同步)

public class TraditionalThreadSynchronized {
    public static void main(String[] args) {
        final Outputter outputter = new Outputter();
        // 運行兩個線程分別輸出名字zhangsan和lisi
        new Thread() {
            public void run() {
                outputter.output("zhangsan");
            }
        }.start();      
        new Thread() {
            public void run() {
                outputter.output("lisi");
            }
        }.start();
    }
}
class Outputter {
    public void output(String name) {
        // TODO 爲了保證對name的輸出不是一個原子操作，這裏逐個輸出name的每個字符
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
            // Thread.sleep(10);
        }
    }
}

運行結果：zhlainsigsan

顯然輸出的字符串被打亂了，我們期望的輸出結果是zhangsanlisi，這就是線程同步問題，我們希望output方法被一個線程完整的執行完之後再切換到下一個線程，Java中使用synchronized保證一段代碼在多線程執行時是互斥的，有兩種用法：
方法 1： 使用synchronized將需要互斥的代碼包含起來，並上一把鎖。

{
    synchronized (this) {
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
        }
    }
}

這把鎖必須是需要互斥的多個線程間的共享對象，像下面的代碼是沒有意義的。

{
    Object lock = new Object();
    synchronized (lock) {
        for(int i = 0; i < name.length(); i++) {
            System.out.print(name.charAt(i));
        }
    }
}

方法2：將synchronized加在需要互斥的方法上。

public synchronized void output(String name) {
    // TODO 線程輸出方法
    for(int i = 0; i < name.length(); i++) {
        System.out.print(name.charAt(i));
    }
}

這種方式就相當於用this鎖住整個方法內的代碼塊，如果用synchronized加在靜態方法上，就相當於用××××.class鎖住整個方法內的代碼塊。使用synchronized在某些情況下會造成死鎖，死鎖問題以後會說明。使用synchronized修飾的方法或者代碼塊可以看成是一個 原子操作。

每個鎖對象(JLS(java語言規範)中叫monitor)都有兩個隊列，一個是就緒隊列，一個是阻塞隊列，就緒隊列存儲了將要獲得鎖的線程，阻塞隊列存儲了被阻塞的線程，當一個線程被喚醒(notify)後，纔會進入到就緒隊列，等待CPU的調度，反之，當一個線程被wait後，就會進入阻塞隊列，等待下一次被喚醒，這個涉及到線程間的通信。看我們的例子，當第一個線程執行輸出方法時，獲得同步鎖，執行輸出方法，恰好此時第二個線程也要執行輸出方法，但發現同步鎖沒有被釋放，第二個線程就會進入就緒隊列，等待鎖被釋放。一個線程執行互斥代碼過程如下：

    1. 獲得同步鎖；

    2. 清空工作內存；

    3. 從主內存拷貝對象副本到工作內存；

    4. 執行代碼(計算或者輸出等)；

    5. 刷新主內存數據；

    6. 釋放同步鎖。

    所以，synchronized既保證了多線程的併發有序性，又保證了多線程的內存可見性。

#### 3.2 Volatile
用volatile修飾的變量，線程在每次使用變量的時候，都會讀取變量修改後的最的值。volatile很容易被誤用，用來進行原子性操作。(那應該如何使用呢？？)

public class Counter {

    public static int count = 0;

    public static void inc() {

        //這裏延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }
        count++;
    }

    public static void main(String[] args) {

        //同時啓動1000個線程，去進行i++計算，看看實際結果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }

        //這裏每次運行的值都有可能不同,可能爲1000
        System.out.println("運行結果:Counter.count=" + Counter.count);
    }
}

運行結果:Counter.count=995

實際運算結果每次可能都不一樣，本機的結果爲：運行結果:Counter.count=995，可以看出，在多線程的環境下，Counter.count並沒有期望結果是1000
很多人以爲，這個是多線程併發問題，只需要在變量count之前加上volatile就可以避免這個問題，那我們在修改代碼看看，看看結果是不是符合我們的期望。

public class Counter {
    // 在count上使用volatile關鍵字
    public volatile static int count = 0;

    public static void inc() {

        //這裏延遲1毫秒，使得結果明顯
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }

        count++;
    }

    public static void main(String[] args) {

        //同時啓動1000個線程，去進行i++計算，看看實際結果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Counter.inc();
                }
            }).start();
        }

        //這裏每次運行的值都有可能不同,可能爲1000
        System.out.println("運行結果:Counter.count=" + Counter.count);
    }
}

運行結果:Counter.count=992

運行結果還是沒有我們期望的1000，下面我們分析一下原因
在 java 垃圾回收整理一文中，描述了jvm運行時刻內存的分配。其中有一個內存區域是JVM棧，每一個線程運行時都有一個線程棧，線程棧保存了線程運行時候變量值信息。當線程訪問某一個對象時候值的時候，首先通過對象的引用找到對應在堆內存的變量的值，然後把堆內存變量的具體值load到線程本地內存中，建立一個變量副本，之後線程就不再和對象在堆內存變量值有任何關係，而是直接修改副本變量的值，在修改完之後的某一個時刻（線程退出之前），自動把線程變量副本的值回寫到對象在堆中變量。這樣在堆中的對象的值就產生變化了。下面一幅圖描述這些交互：

read and load 從主存複製變量到當前工作內存
use and assign 執行代碼，改變共享變量值
store and write 用工作內存數據刷新主存相關內容

其中use and assign 可以多次出現

但是這一些操作並不是原子性，也就是在read load之後，如果主內存count變量發生修改之後，線程工作內存中的值由於已經加載，不會產生對應的變化，所以計算出來的結果會和預期不一樣

對於volatile修飾的變量，jvm虛擬機只是保證從主內存加載到線程工作內存的值是當前最新的

例如假如線程1，線程2 在進行read,load 操作中，發現主內存中count的值都是5，那麼都會加載這個最新的值

在線程1堆count進行修改之後，會write到主內存中，主內存中的count變量就會變爲6

線程2由於已經進行read,load操作，在進行運算之後，也會更新主內存count的變量值爲6

導致兩個線程及時用volatile關鍵字修改之後，還是會存在併發的情況。(所以volatile用來幹啥？:( )

線程安全和線程同步Synchronized

1. 概念

2. 安全性

3. 線程同步

3.1 Synchronized(同步)

線程安全和線程同步Synchronized

Ubuntu簡易配置dlna服務器

[225] Implement Stack using Queues

Android LayoutInflater.inflate詳解

[70] Climbing Stairs

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結