java中如何使方法線程安全（java怎麼實現線程安全）

• 1、如何創建線程？如何保證線程安全？
• 2、Java中如何保證線程安全性
• 3、如何確保Java線程安全？
• 4、Java的List如何實現線程安全？
• 5、java 程序中怎麼保證多線程的運行安全？
• 6、昆明java培訓學校告訴你關於線程安全問題分析？

在java中如果要創建線程的話，一般有兩種方式：

1.繼承Thread類；

2.實現Runnable接口。

線程安全：

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

一般說來，確保線程安全的方法有這幾個：競爭與原子操作、同步與鎖、可重入、過度優化。

個人認為，保證線程安全，無外乎保持線程同步的方式，

如：@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex、OSSpinLock。

然而：

OSSpinLock和dispatch_semaphore的效率遠遠高於其他。

@synchronized和NSConditionLock效率較差。

鑒於OSSpinLock的不安全，所以我們在開發中如果考慮性能的話，建議使用dispatch_semaphore。

如果不考慮性能，只是圖個方便的話，那就使用@synchronized。

如何保證呢：

1.使用線程安全的類；

使用synchronized同步代碼塊，或者用Lock鎖；

由於線程安全問題，使用synchronized同步代碼塊     原理：當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程得到執行。     另一個線程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。

多線程並發情況下，線程共享的變量改為方法局部級變量；

作者：squirrels

鏈接：

來源：簡書

著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。

並發（concurrency）一個並不陌生的詞，簡單來說，就是cpu在同一時刻執行多個任務。

而Java並發則由多線程實現的。

在jvm的世界裡，線程就像不相干的平行空間，串行在虛擬機中。（當然這是比較籠統的說法，線程之間是可以交互的，他們也不一定是串行。）

多線程的存在就是壓榨cpu，提高程序性能，還能減少一定的設計複雜度（用現實的時間思維設計程序）。

這麼說來似乎線程就是傳說中的銀彈了，可事實告訴我們真正的銀彈並不存在。

多線程會引出很多難以避免的問題， 如死鎖，臟數據，線程管理的額外開銷，等等。更大大增加了程序設計的複雜度。

但他的優點依舊不可替代。

死鎖和臟數據就是典型的線程安全問題。

簡單來說，線程安全就是： 在多線程環境中，能永遠保證程序的正確性。

只有存在共享數據時才需要考慮線程安全問題。

java內存區域：

其中， 方法區和堆就是主要的線程共享區域。那麼就是說共享對象只可能是類的屬性域或靜態域。

了解了線程安全問題的一些基本概念後， 我們就來說說如何解決線程安全問題。我們來從一個簡單的servlet示例來分析：

public class ReqCounterServlet extends HttpServlet{    private int count = 0;

public void doGet(HttpServletRequest request,

HttpServletResponse response) throws IOException, ServletException {

count++;

System.out.print(“當前已達到的請求數為” + count);

}

public void doPost(HttpServletRequest request,

HttpServletResponse response) throws IOException, ServletException {        // ignore    }

}

1. 了解業務場景的線程模型

這裡的線程模型指的是: 在該業務場景下， 可能出現的線程調用實況。

眾所周知，Servlet是被設計為單實例，在請求進入tomcat後，由Connector建立連接，再講請求分發給內部線程池中的Processor，

此時Servlet就處於一個多線程環境。即如果存在幾個請求同時訪問某個servlet，就可能會有幾個線程同時訪問該servlet對象。如圖：

線程模型，如果簡單的話，就在腦海模擬一下就好了，複雜的話就可以用紙筆或其他工具畫出來。

2. 找出共享對象

這裡的共享對象就很明顯就是ReqCounterServlet。

3. 分析共享對象的不變性條件

不變性條件，這個名詞是在契約式編程的概念中的。不變性條件保證類的狀態在任何功能被執行後都保持在一個可接受的狀態。

這裡可以引申出， 不可變對象是線程安全的。（因為不可變對象就沒有不變性條件）

不變性條件則主要由對可變狀態的修改與訪問構成。

這裡的servlet很簡單， 不變性條件大致可以歸納為： 每次請求進入時count計數必須加一，且計數必須正確。

在複雜的業務中， 類的不變性條件往往很難考慮周全。設計的世界是險惡的，只能小心謹慎，用測量去證明，最大程度地減少錯誤出現的幾率。

4. 用特定的策略解決線程安全問題。

如何解決的確是該流程的重點。目前分三種方式解決：

第一種，修改線程模型。即不在線程之間共享該狀態變量。一般這個改動比較大，需要量力而行。

第二種，將對象變為不可變對象。有時候實現不了。

第三種，就比較通用了，在訪問狀態變量時使用同步。 synchronized和Lock都可以實現同步。簡單點說，就是在你修改或訪問可變狀態時加鎖，獨佔對象，讓其他線程進不來。

這也算是一種線程隔離的辦法。（這種方式也有不少缺點，比如說死鎖，性能問題等等）

其實有一種更好的辦法，就是設計線程安全類。《代碼大全》就有提過，問題解決得越早，花費的代價就越小。

是的，在設計時，就考慮線程安全問題會容易的多。

首先考慮該類是否會存在於多線程環境。如果不是，則不考慮線程安全。

然後考慮該類是否能設計為不可變對象，或者事實不可變對象。如果是，則不考慮線程安全

最後，根據流程來設計線程安全類。

設計線程安全類流程：

1、找出構成對象狀態的所有變量。

2、找出約束狀態變量的不變性條件。

3、建立對象狀態的並發訪問管理策略。

有兩種常用的並發訪問管理策略：

1、java監視器模式。  一直使用某一對象的鎖來保護某狀態。

2、線程安全委託。　 將類的線程安全性委託給某個或多個線程安全的狀態變量。（注意多個時，這些變量必須是彼此獨立，且不存在相關聯的不變性條件。）

在Java中可以有很多方法來保證線程安全——同步，使用原子類(atomicconcurrentclasses)，實現並發鎖，使用volatile關鍵字，使用不變類和線程安全類。

Java的List如何實現線程安全？

Collections.synchronizedList(names);效率最高，線程安全

Java的List是我們平時很常用的集合，線程安全對於高並發的場景也十分的重要，那麼List如何才能實現線程安全呢 ？

加鎖

首先大家會想到用Vector，這裡我們就不討論了，首先討論的是加鎖，例如下面的代碼

public class Synchronized{

private ListString  names = new LinkedList();

public synchronized void addName(String name ){

names.add(“abc”);

}

public String getName(Integer index){

Lock lock =new ReentrantLock();

lock.lock();

try {

return names.get(index);

}catch (Exception e){

e.printStackTrace();

}

finally {

lock.unlock();

}

return null;

}

}

synchronized一加，或者使用lock 可以實現線程安全，但是這樣的List要是很多個，代碼量會大大增加。

java自帶類

在java中我找到自帶有兩種方法

CopyOnWriteArrayList

CopyOnWrite 寫入時複製，它使一個List同步的替代品，通常情況下提供了更好的並發性，並且避免了再迭代時候對容器的加鎖和複製。通常更適合用於迭代，在多插入的情況下由於多次的複製性能會一定的下降。

下面是add方法的源代碼

 public boolean add(E e) {

final ReentrantLock lock = this.lock; // 加鎖 只允許獲得鎖的線程訪問

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

// 創建個長度加1的數組並複製過去

Object[] newElements = Arrays.copyOf(elements, len + 1);

newElements[len] = e; // 賦值

setArray(newElements); // 設置內部的數組

return true;

} finally {

lock.unlock();

}

}

Collections.synchronizedList

Collections中有許多這個系列的方法例如

主要是利用了裝飾者模式對傳入的集合進行調用 Collotions中有內部類SynchronizedList

static class SynchronizedListE

extends SynchronizedCollectionE

implements ListE {

private static final long serialVersionUID = -7754090372962971524L;

final ListE list;

SynchronizedList(ListE list) {

super(list);

this.list = list;

}

public E get(int index) {

synchronized (mutex) {return list.get(index);}

}

public E set(int index, E element) {

synchronized (mutex) {return list.set(index, element);}

}

public void add(int index, E element) {

synchronized (mutex) {list.add(index, element);}

}

public E remove(int index) {

synchronized (mutex) {return list.remove(index);}

}

static class SynchronizedCollectionE implements CollectionE, Serializable {

private static final long serialVersionUID = 3053995032091335093L;

final CollectionE c;  // Backing Collection

final Object mutex;     // Object on which to synchronize

這裡上面的mutex就是鎖的對象 在構建時候可以指定鎖的對象 主要使用synchronize關鍵字實現線程安全

 /**

* @serial include

*/

static class SynchronizedListE

extends SynchronizedCollectionE

implements ListE {

private static final long serialVersionUID = -7754090372962971524L;

final ListE list;

SynchronizedList(ListE list) {

super(list);

this.list = list;

}

SynchronizedList(ListE list, Object mutex) {

super(list, mutex);

this.list = list;

}

這裡只是列舉SynchronizedList ，其他類類似，可以看下源碼了解下。

測試

public class Main {

public static void main(String[] args) {

ListString names = new LinkedList();

names.add(“sub”);

names.add(“jobs”);

// 同步方法1 內部使用lock

long a = System.currentTimeMillis();

ListString strings = new CopyOnWriteArrayList(names);

for (int i = 0; i 100000; i++) {

strings.add(“param1”);

}

long b = System.currentTimeMillis();

// 同步方法2 裝飾器模式使用 synchronized

ListString synchronizedList = Collections.synchronizedList(names);

for (int i = 0; i 100000; i++) {

synchronizedList.add(“param2”);

}

long c = System.currentTimeMillis();

System.out.println(“CopyOnWriteArrayList time == “+(b-a));

System.out.println(“Collections.synchronizedList time == “+(c-b));

}

}

兩者內部使用的方法都不一樣，CopyOnWriteArrayList內部是使用lock進行加鎖解鎖完成單線程訪問，synchronizedList使用的是synchronize

進行了100000次添加後時間對比如下：

可以看出來還是使用了synchronize的集合工具類在添加方面更加快一些，其他方法這裡篇幅關係就不測試了，大家有興趣去試一下。

並發編程三要素（線程的安全性問題體現在）：

原子性：原子，即一個不可再被分割的顆粒。原子性指的是一個或多個操作要麼 全部執行成功要麼全部執行失敗。

可見性：一個線程對共享變量的修改,另一個線程能夠立刻看到。 （synchronized,volatile）

有序性：程序執行的順序按照代碼的先後順序執行。（處理器可能會對指令進行 重排序）

出現線程安全問題的原因：

線程切換帶來的原子性問題

緩存導致的可見性問題

編譯優化帶來的有序性問題

解決辦法：

JDK Atomic開頭的原子類、synchronized、LOCK，可以解決原子性問題

synchronized、volatile、LOCK，可以解決可見性問題

Happens-Before 規則可以解決有序性問題

在學習java編程開發語言的過程中，我們掌握了線程與線程池等相關技術知識。今天，北大青鳥雲南計算機學院就關於線程安全問題給大家做一個簡單的說明和介紹，一起來了解一下吧。

線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。

線程不安全就是不提供數據訪問保護，有可能出現多個線程先後更改數據造成所得到的數據是臟數據。

什麼時候考慮到線程安全：

一個對象是否需要線程安全，取決於該對象是否被多線程訪問。這指的是程序中訪問對象的方式，而不是對象要實現的功能。要使得對象是線程安全的，要採用同步機制來協同對對象可變狀態的訪問。Java常用的同步機制是Synchronized，還包括volatile類型的變量，顯示鎖以及原子變量。在多個線程中，當它們同時訪問同個類時，每次執行的結果和單線程結果一致，且變量值跟預期一致，這個類則是線程安全的。

鎖的特性

鎖機制的兩種特性：

互斥性：即同一時間只允許一個線程持有某個對象的鎖，通過這種特性來實現多線程中的協調機制，這樣在同一時間只有一個線程對需同步的代碼塊(複合操作)進行訪問。互斥性我們也往往稱為操作的原子性。

可見性：必須確保在鎖被釋放之前，對共享變量所做的修改，對於隨後獲得該鎖的另一個線程是可見的，否則另一個線程可能是在本地緩存的某個副本上繼續操作從而引起不一致。

掛起、休眠、阻塞和非阻塞

掛起：當線程被掛起時，其會失去CPU的使用時間，直到被其他線程(用戶線程或調試線程)喚醒。

休眠：同樣是會失去CPU的使用時間，但是在過了指定的休眠時間之後，它會自動激活，無需喚醒(整個喚醒表面看是自動的，但實際上也得有守護線程去喚醒，只是不需編程者手動干預)。

阻塞：在線程執行時，所需要的資源不能得到，則線程被掛起，直到滿足可操作的條件。

非阻塞：在線程執行時，所需要的資源不能得到，則線程不是被掛起等待，而是繼續執行其餘事情，等待條件滿足了後，收到了通知(同樣是守護線程去做)再執行。