閱讀更多

蓝球专论15127期一码定蓝:
編程語言
特約稿件 Java并發教程(Oracle官方資料)  

2014-04-16  編輯 wangguo 評論(100條) 有283276人瀏覽
本文是Oracle官方的Java并發相關的教程,感謝并發編程網的翻譯和投遞。

(關注ITeye官微,隨時隨地查看最新開發資訊、技術文章。)

計算機的使用者一直以為他們的計算機可以同時做很多事情。他們認為當其他的應用程序在下載文件,管理打印隊列或者緩沖音頻的時候他們可以繼續在文字處理程序上工作。甚至對于單個應用程序,他們任然期待它能在在同一時間做很多事情。舉個例子,一個流媒體播放程序必須能同時完成以下工作:從網絡上讀取數字音頻,解壓縮數字音頻,管理播放和更新程序顯示。甚至文字處理器也應該能在忙于重新格式化文本和刷新顯示的情況下同時響應鍵盤和鼠標事件。這樣的軟件就被稱為并發軟件。

通過Java語言和Java類庫對于基礎并發的支持,Java平臺具有完全(from the ground up )支持并發編程的能力。從JDK5.0起,Java平臺還引入了高級并發APIs。這個課程不僅涵蓋了Java平臺基礎并發內容,還對高級并發APIs有一定的闡述。

進程和線程 Top



(本部分原文鏈接,譯文鏈接,譯者:bjsuo,校對:鄭旭東)
在并發編程中,有兩個基本的執行單元:進程和線程。在java語言中,并發編程最關心的是線程,然而,進程也是非常重要的。

即使在只有單一的執行核心的計算機系統中,也有許多活動的進程和線程。因此,在任何給定的時刻,只有一個線程在實際執行。處理器的處理時間是通過操作系統的時間片在進程和線程中共享的。

現在具有多處理器或有多個執行內核的多處理器的計算機系統越來越普遍,這大大增強了系統并發執行的進程和線程的吞吐量–但在不沒有多個處理器或執行內核的簡單的系統中,并發任然是可能的。

進程

進程具有一個獨立的執行環境。通常情況下,進程擁有一個完整的、私有的基本運行資源集合。特別地,每個進程都有自己的內存空間。

進程往往被看作是程序或應用的代名詞,然而,用戶看到的一個單獨的應用程序實際上可能是一組相互協作的進程集合。為了便于進程之間的通信,大多數操作系統都支持進程間通信(IPC),如pipes 和sockets。IPC不僅支持同一系統上的通信,也支持不同的系統。

Java虛擬機的大多數實現是單進程的。Java應用可以使用的ProcessBuilder對象創建額外的進程,多進程應用超出了本課的范圍。

線程

線程有時也被稱為輕量級的進程。進程和線程都提供了一個執行環境,但創建一個新的線程比創建一個新的進程需要的資源要少。

線程是在進程中存在的 — 每個進程最少有一個線程。線程共享進程的資源,包括內存和打開的文件。這樣提高了效率,但潛在的問題就是線程間的通信。

多線程的執行是Java平臺的一個基本特征。每個應用都至少有一個線程 – 或幾個,如果算上“系統”線程的話,比如內存管理和信號處理等。但是從程序員的角度來看,啟動的只有一個線程,叫主線程。這個線程有能力創建額外的線程,我們將在下一節演示。

線程對象 Top


(本部分原文鏈接,譯文鏈接,譯者:鄭旭東)
在Java中,每個線程都是Thread類的實例。并發應用中一般有兩種不同的線程創建策略。

  • 直接控制線程的創建和管理,每當應用程序需要執行一個異步任務的時候就為其創建一個線程
  • 將線程的管理從應用程序中抽象出來作為執行器,應用程序將任務傳遞給執行器,有執行器負責執行。
這一節,我們將討論Thread對象,有關Executors將在高級并發對象一節中討論。

定義并啟動一個線程

應用程序在創建一個線程實例時,必須提供需要在線程中運行的代碼。有兩種方式去做到這一點:

  • 提供一個Runnable對象。Runnable對象僅包含一個run()方法,在這個方法中定義的代碼將在會線程中執行。將Runnable對象傳遞給Thread類的構造函數即可,如下面這個HelloRunnable的例子:

 双色球17042期蓝球预测 www.bqqtcg.com.cn public class HelloRunnable implements Runnable {

    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }

}



  • 繼承Thread類。Thread類自身已實現了Runnable接口,但它的run()方法中并沒有定義任何代碼。應用程序可以繼承與Thread類,并復寫run()方法。如例子HelloThread

public class HelloThread extends Thread {

    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new HelloThread()).start();
    }

}


需要注意的是,上述兩個例子都需要調用Thread.start()方法來啟動一個新的線程。 哪一種方式是我們應該使用的?相對來說,第一種更加通用,因為Runnable對象可以繼承于其他類(Java只支持單繼承,當一個類繼承與Thread類后,就無法繼承與其他類)。第二種方法更易于在簡單的應用程序中使用,但它的局限就是:你的任務類必須是Thread的子類。這個課程更加聚焦于第一種將Runnable任務和Thread類分離的方式。不僅僅是因為這種方式更加靈活,更因為它更適合后面將要介紹的高級線程管理API。 Thread類定義了一些對線程管理十分有用的的方法。在這些方法中,有一些靜態方法可以給當前線程調用,它們可以提供一些有關線程的信息,或者影響線程的狀態。而其他一些方法可以由其他線程進行調用,用于管理線程和Thread對象。我們將在下面的章節中,深入探討這些內容。

使用Sleep方法暫停一個線程

使用Thread.sleep()方法可以暫停當前線程一段時間。這是一種使處理器時間可以被其他線程或者運用程序使用的有效方式。sleep()方法還可以用于調整線程執行節奏(見下面的例子)和等待其他有執行時間需求的線程(這個例子將在下一節演示)。
在Thread中有兩個不同的sleep()方法,一個使用毫秒表示休眠的時間,而另一個是用納秒。由于操作系統的限制休眠時間并不能保證十分精確。休眠周期可以被interrups所終止,我們將在后面看到這樣的例子。不管在任何情況下,我們都不應該假定調用了sleep()方法就可以將一個線程暫停一個十分精確的時間周期。

SleepMessages程序為我們展示了使用sleep()方法每四秒打印一個信息的例子

public class SleepMessages {
    public static void main(String args[])
        throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };

        for (int i = 0;
             i < importantInfo.length;
             i++) {
            //Pause for 4 seconds
            Thread.sleep(4000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}



main()方法聲明了它有可能拋出InterruptedException。當其他線程中斷當前線程時,sleep()方法就會拋出該異常。由于這個應用程序并沒有定義其他的線程,所以并不用關心如何處理該異常。

中斷(Interrupts)

中斷是給線程的一個指示,告訴它應該停止正在做的事并去做其他事情。一個線程究竟要怎么響應中斷請求取決于程序員,不過讓其終止是很普遍的做法。這是本文重點強調的用法。

一個線程通過調用對被中斷線程的Thread對象的interrupt()方法,發送中斷信號。為了讓中斷機制正常工作,被中斷的線程必須支持它自己的中斷(即要自己處理中斷)

中斷支持

線程如何支持自身的中斷?這取決于它當前正在做什么。如果線程正在頻繁調用會拋InterruptedException異常的方法,在捕獲異常之后,它只是從run()方法中返回。例如,假設在SleepMessages的例子中,關鍵的消息循環在線程的Runnable對象的run方法中,代碼可能會被修改成下面這樣以支持中斷:

for (int i = 0; i < importantInfo.length; i++) {
    // Pause for 4 seconds
    try {
       Thread.sleep(4000);
    } catch (InterruptedException e) {
       // We've been interrupted: no more messages.
      return;
 }
 // Print a message
 System.out.println(importantInfo[i]);
}



許多會拋InterruptedException異常的方法(如sleep()),被設計成接收到中斷后取消它們當前的操作,并在立即返回。

如果一個線程長時間運行而不調用會拋InterruptedException異常的方法會怎樣? 那它必須周期性地調用Thread.interrupted()方法,該方法在接收到中斷請求后返回true。例如:

for (int i = 0; i < inputs.length; i++) {
    heavyCrunch(inputs[i]);
    if (Thread.interrupted()) {
        // We've been interrupted: no more crunching.
        return;
    }
}


在這個簡單的例子中,代碼只是檢測中斷,并在收到中斷后退出線程。在更復雜的應用中,拋出一個InterruptedException異??贍芨幸庖?。

if (Thread.interrupted()){
   throw new InterruptedException();
}


這使得中斷處理代碼能集中在catch語句中。

中斷狀態標記

中斷機制通過使用稱為中斷狀態的內部標記來實現。調用Thread.interrupt()設置這個標記。當線程通過調用靜態方法Thread.interrupted()檢測中斷時,中斷狀態會被清除。非靜態的isInterrupted()方法被線程用來檢測其他線程的中斷狀態,不改變中斷狀態標記。

按照慣例,任何通過拋出一個InterruptedException異常退出的方法,當拋該異常時會清除中斷狀態。不過,通過其他的線程調用interrupt()方法,中斷狀態總是有可能會立即被重新設置。

Joins

Join()方法可以讓一個線程等待另一個線程執行完成。若t是一個正在執行的Thread對象,

t.join();


將會使當前線程暫停執行并等待t執行完成。重載的join()方法可以讓開發者自定義等待周期。然而,和sleep()方法一樣join()方法依賴于操作系統的時間處理機制,你不能假定join()方法將會精確的等待你所定義的時長。
如同sleep()方法,join()方法響應中斷并在中斷時拋出InterruptedException。

一個簡單的線程例子

下面這個簡單的例子將會把這一節的一些概念放到一起演示。SimpleThreads程序有兩個線程組成,第一個是主線程,它從創建了一個線程并等待它執行完成。如果MessageLoop線程執行了太長時間,主線程將會將其中斷。
MessageLoop現場將會打印一系列的信息。如果中斷在它打印完所有信息前發生,它將會打印一個特定的消息并退出。

public class SimpleThreads {

    // Display a message, preceded by
    // the name of the current thread
    static void threadMessage(String message) {
        String threadName =
            Thread.currentThread().getName();
        System.out.format("%s: %s%n",
                          threadName,
                          message);
    }

    private static class MessageLoop
        implements Runnable {
        public void run() {
            String importantInfo[] = {
                "Mares eat oats",
                "Does eat oats",
                "Little lambs eat ivy",
                "A kid will eat ivy too"
            };
            try {
                for (int i = 0;
                     i < importantInfo.length;
                     i++) {
                    // Pause for 4 seconds
                    Thread.sleep(4000);
                    // Print a message
                    threadMessage(importantInfo[i]);
                }
            } catch (InterruptedException e) {
                threadMessage("I wasn't done!");
            }
        }
    }

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

        // Delay, in milliseconds before
        // we interrupt MessageLoop
        // thread (default one hour).
        long patience = 1000 * 60 * 60;

        // If command line argument
        // present, gives patience
        // in seconds.
        if (args.length > 0) {
            try {
                patience = Long.parseLong(args[0]) * 1000;
            } catch (NumberFormatException e) {
                System.err.println("Argument must be an integer.");
                System.exit(1);
            }
        }

        threadMessage("Starting MessageLoop thread");
        long startTime = System.currentTimeMillis();
        Thread t = new Thread(new MessageLoop());
        t.start();

        threadMessage("Waiting for MessageLoop thread to finish");
        // loop until MessageLoop
        // thread exits
        while (t.isAlive()) {
            threadMessage("Still waiting...");
            // Wait maximum of 1 second
            // for MessageLoop thread
            // to finish.
            t.join(1000);
            if (((System.currentTimeMillis() - startTime) > patience)
                  && t.isAlive()) {
                threadMessage("Tired of waiting!");
                t.interrupt();
                // Shouldn't be long now
                // -- wait indefinitely
                t.join();
            }
        }
        threadMessage("Finally!");
    }
}


同步 Top



(本部分原文鏈接,譯文鏈接,譯者:蘑菇街-小寶,Greenster,李任  校對:丁一,鄭旭東,李任
線程間的通信主要是通過共享域和引用相同的對象。這種通信方式非常高效,不過可能會引發兩種錯誤:線程干擾和內存一致性錯誤。防止這些錯誤發生的方法是同步。

不過,同步會引起線程競爭,當兩個或多個線程試圖同時訪問相同的資源,隨之就導致Java運行時環境執行其中一個或多個線程比原先慢很多,甚至執行被掛起,這就出現了線程競爭。線程饑餓和活鎖都屬于線程競爭的范疇。關于線程競爭的更多信息可參考活躍度一節。

本節內容包括以下這些主題:

  • 線程干擾討論了當多個線程訪問共享數據時錯誤是怎么發生的。
  • 內存一致性錯誤討論了不一致的共享內存視圖導致的錯誤。
  • 同步方法討論了 一種能有效防止線程干擾和內存一致性錯誤的常見做法。
  • 內部鎖和同步討論了更通用的同步方法,以及同步是如何基于內部鎖實現的。
  • 原子訪問討論了不能被其他線程干擾的操作的總體思路。
1.  線程干擾

下面這個簡單的Counter類:

class Counter {
    private int c = 0;
    public void increment() {
        c++;
    }
    public void decrement() {
        c--;
    }
    public int value() {
        return c;
    }
}


Counter類被設計成:每次調用increment()方法,c的值加1;每次調用decrement()方法,c的值減1。如果當同一個Counter對象被多個線程引用,線程間的干擾可能會使結果同我們預期的不一致。

當兩個運行在不同的線程中卻作用在相同的數據上的操作交替執行時,就發生了線程干擾。這意味著這兩個操作都由多個步驟組成,而步驟間的順序產生了重疊。

Counter類實例的操作會交替執行,這看起來似乎不太可能,因為c上的這兩個操作都是單一而簡單的語句。然而,即使一個簡單的語句也會被虛擬機轉換成多個步驟。我們不去深究虛擬機內部的詳細執行步驟——理解c++這個單一的語句會被分解成3個步驟就足夠了:

  • 獲取當前c的值;
  • 對獲取到的值加1;
  • 把遞增后的值寫回到c;
語句c–也可以按同樣的方式分解,除了第二步的操作是遞減而不是遞增。

假設線程A調用increment()的同時線程B調用decrement().如果c的初始值為0,線程A和B之間的交替執行順序可能是下面這樣:

  • 線程A:獲取c;
  • 線程B:獲取c;
  • 線程A:對獲取的值加1,結果為1;
  • 線程B:對獲取的值減1,結果為-1;
  • 線程A:結果寫回到c,c現在是1;
  • 線程B:結果寫回到c,c現在是-1;
線程A的結果因為被線程B覆蓋而丟失了。這個交替執行的結果只是其中一種可能性。在不同的環境下,可能是線程B的結果丟失了,也可能是不會出任何問題。由于結果是不可預知的,所以線程干擾的bug很難檢測和修復。

2.  內存一致性錯誤

當不同的線程對相同的數據產生不一致的視圖時會發生內存一致性錯誤。內存一致性錯誤的原因比較復雜,也超出了本教程的范圍。不過幸運的是,一個程序員并不需要對這些原因有詳細的了解。所需要的是避免它們的策略。

避免內存一致性錯誤的關鍵是理解happens-before關系。這種關系只是確保一個特定語句的寫內存操作對另外一個特定的語句可見。要說明這個問題,請參考下面的例子。假設定義和初始化了一個簡單int字段:

int counter =0 ;


這個counter字段被A,B兩個線程共享。假設線程A對counter執行遞增:

counter++;


然后,很快的,線程B輸出counter:

System.out.println(counter);


如果這兩個語句已經在同一個線程中被執行過,那么輸出的值應該是“1”。不過如果這兩個語句在不同的線程中分開執行,那輸出的值很可能是“0”,因為無法保證線程A對counter的改動對線程B是可見的——除非我們在這兩個語句之間已經建立了happens-before關系。

有許多操作會建立happens-before關系。其中一個是同步,我們將在下面的章節中看到。
我們已經見過兩個建立happens-before關系的操作。

當一條語句調用Thread.start方法時,和該語句有happens-before關系的每一條語句,跟新線程執行的每一條語句同樣有happens-before關系。創建新線程之前的代碼的執行結果對線新線程是可見的。

當一個線程終止并且當導致另一個線程中Thread.join返回時,被終止的線程執行的所有語句和在join返回成功之后的所有語句間有happens-before關系。線程中代碼的執行結果對執行join操作的線程是可見的。

要查看建立happens-before關系的操作列表,請參閱java.util.concurrent包的摘要頁面。

3.  同步方法

Java編程語言提供兩種同步方式:同步方法和同步語句。相對較復雜的同步語句將在下一節中介紹。本節主要關注同步方法。

要讓一個方法成為同步方法,只需要在方法聲明中加上synchronized關鍵字:

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}


如果count是SynchronizedCounter類的實例,那么讓這些方法成為同步方法有兩個作用:
首先,相同對象上的同步方法的兩次調用,它們要交替執行是不可能的。 當一個線程正在執行對象的同步方法時,所有其他調用該對象同步方法的線程會被阻塞(掛起執行),直到第一個線程處理完該對象。

其次,當一個同步方法退出時,它會自動跟該對象同步方法的任意后續調用建立起一種happens-before關系。這確保對象狀態的改變對所有線程是可見的。

注意構造方法不能是同步的——構造方法加synchronized關鍵字會報語法錯誤。同步的構造方法沒有意義,因為當這個對象被創建的時候,只有創建對象的線程能訪問它。

警告:當創建的對象會被多個線程共享時必須非常小心,對象的引用不要過早“暴露”出去。比如,假設你要維護一個叫instances的List,它包含類的每一個實例對象。你可能會嘗試在構造方法中加這樣一行:

instances.add(this);


不過其他線程就能夠在對象構造完成之前使用instances訪問對象。

同步(synchronized)方法使用一種簡單的策略來防止線程干擾和內存一致性錯誤:如果一個對象對多個線程可見,對象域上的所有讀寫操作都是通過synchronized方法來完成的。(一個重要的例外:final域,在對象被創建后不可修改,能被非synchronized方法安全的讀?。?。synchronized同步策略很有效,不過會引起活躍度問題,我們將在本節后面看到。

4.  內部鎖與同步

同步機制的建立是基于其內部一個叫內部鎖或者監視鎖的實體。(在Java API規范中通常被稱為監視器。)內部鎖在同步機制中起到兩方面的作用:對一個對象的排他性訪問;建立一種happens-before關系,而這種關系正是可見性問題的關鍵所在。

每個對象都有一個與之關聯的內部鎖。通常當一個線程需要排他性的訪問一個對象的域時,首先需要請求該對象的內部鎖,當訪問結束時釋放內部鎖。在線程獲得內部鎖到釋放內部鎖的這段時間里,我們說線程擁有這個內部鎖。那么當一個線程擁有一個內部鎖時,其他線程將無法獲得該內部鎖。其他線程如果去嘗試獲得該內部鎖,則會被阻塞。

當線程釋放一個內部鎖時,該操作和對該鎖的后續請求間將建立happens-before關系。

5.  同步方法中的鎖

當線程調用一個同步方法時,它會自動請求該方法所在對象的內部鎖。當方法返回結束時則自動釋放該內部鎖,即使退出是由于發生了未捕獲的異常,內部鎖也會被釋放。

你可能會問調用一個靜態的同步方法會如何,由于靜態方法是和類(而不是對象)相關的,所以線程會請求類對象(Class Object)的內部鎖。因此用來控制類的靜態域訪問的鎖不同于控制對象訪問的鎖。

6.  同步塊

另外一種同步的方法是使用同步塊。和同步方法不同,同步塊必須指定所請求的是哪個對象的內部鎖:
public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
    }
    nameList.add(name);
}


在上面的例子中,addName方法需要使lastName和nameCount的更改保持同步,而且要避免同步調用該對象的其他方法。(在同步代碼中調用其他方法會產生Liveness一節所描述的問題。)如果不使用同步塊,那么必須要定義一個額外的非同步方法,而這個方法僅僅是用來調用nameList.add。

使用同步塊對于更細粒度的同步很有幫助。例如類MsLunch有兩個實例域c1和c2,他們并不會同時使用(譯者注:即c1和c2是彼此無關的兩個域),所有對這兩個域的更新都需要同步,但是完全不需要防止c1的修改和c2的修改相互之間干擾(這樣做只會產生不必要的阻塞而降低了并發性)。這種情況下不必使用同步方法,可以使用和this對象相關的鎖。這里我們創建了兩個“鎖”對象(譯者注:起到加鎖效果的普通對象lock1和lock2)。

public class MsLunch {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }

    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}


使用這種方法時要特別小心,需要十分確定c1和c2是彼此無關的域。

7.  可重入同步

還記得嗎,一個線程不能獲得其他線程所擁有的鎖。但是它可以獲得自己已經擁有的鎖。允許一個線程多次獲得同一個鎖實現了可重入同步。這里描述了一種同步代碼的場景,直接的或間接地,調用了一個也擁有同步代碼的方法,且兩邊的代碼使用的是同一把鎖。如果沒有這種可重入的同步機制,同步代碼則需要采取許多額外的預防措施以防止線程阻塞自己。

8.  原子訪問

在編程過程中,原子操作是指所有操作都同時發生。原子操作不能被中途打斷:要么全做,要么不做。原子操作在完成前不會有看得見的副作用。

我們發現像c++這樣的增量表達式,并沒有描述原子操作。即使是非常簡單的表達式也能夠定義成能被分解為其他操作的復雜操作。然而,有些操作你可以定義為原子的:

  • 對引用變量和大部分基本類型變量(除long和double之外)的讀寫是原子的。
  • 對所有聲明為volatile的變量(包括long和double變量)的讀寫是原子的。

原子操作不會交錯,于是可以放心使用,不必擔心線程干擾。然而,這并不能完全消除原子操作上的同步,因為內存一致性錯誤仍可能發生。使用volatile變量可以降低內存一致性錯誤的風險,因為對volatile變量的任意寫操作,對于后續在該變量上的讀操作建立了happens-before關系。這意味著volatile變量的修改對于其他線程總是可見的。更重要的是,這同時也意味著當一個線程讀取一個volatile變量時,它不僅能看到該變量最新的修改,而且也能看到致使該改變發生的代碼的副效應。

使用簡單的原子變量訪問比通過同步代碼來訪問更高效,但是需要程序員更加謹慎以避免內存一致性錯誤。至于這額外的付出是否值得,得看應用的大小和復雜度。

java.util.concurrent包中的一些類提供了一些不依賴同步機制的原子方法。我們將在高級并發對象這一節中討論它們。

活躍度 Top



(本部分原文地址,譯文地址,譯者:李任,鄭旭東 校對:蘑菇街-小寶
一個并發應用程序能及時執行的能力稱為活躍性。本節將介紹最常見的活躍性問題:死鎖(deadlock),以及另外兩個活躍性問題:饑餓(starvation)和活鎖(livelock)。

1.  死鎖

死鎖描述了這樣一種情景,兩個或多個線程永久阻塞,互相等待對方釋放資源。下面是一個例子。

Alphone和Gaston是朋友,都很講究禮節。禮節有一個嚴格的規矩,當你向一個朋友鞠躬時,你必須保持鞠躬的姿勢,直到你的朋友有機會回鞠給你。不幸的是,這個規矩沒有算上兩個朋友相互同時鞠躬的可能。

下面的應用例子,DeadLock,模擬了這個可能性。

   static class Friend {
        private final String name;
        public Friend(String name) {
            this.name = name;
        }
        public String getName() {
            return this.name;
        }
        public synchronized void bow(Friend bower) {
            System.out.format("%s: %s"
                + "  has bowed to me!%n",
                this.name, bower.getName());
            bower.bowBack(this);
        }
        public synchronized void bowBack(Friend bower) {
            System.out.format("%s: %s"
                + " has bowed back to me!%n",
                this.name, bower.getName());
        }
    }

    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new Runnable() {
            public void run() { alphonse.bow(gaston); }
        }).start();
        new Thread(new Runnable() {
            public void run() { gaston.bow(alphonse); }
        }).start();
    }
}



當DeadLock運行后,兩個線程極有可能阻塞,當它們嘗試調用bowBack方法時。沒有哪個阻塞會結束,因為每個線程都在等待另一個線程退出bow方法。

2.  饑餓和活鎖

饑餓和活鎖并不如死鎖一般普遍,但它仍然是每個并發程序設計者可能會遇到的問題。

饑餓

饑餓是指當一個線程不能正常的訪問共享資源并且不能正常執行的情況。這通常在共享資源被其他“貪心”的線程長期時發生。舉個例子,假設一個對象提供了一個同步方法,這個方法通常需要執行很長一段時間才返回。如果一個線程經常調用這個方法,那么其他需要同步的訪問這個對象的線程就經?;岜蛔樅?。

活鎖

一個線程通?;嵊謝嵯煊ζ淥叱痰幕疃?。如果其他線程也會響應另一個線程的活動,那么就有可能發生活鎖。同死鎖一樣,發生活鎖的線程無法繼續執行。然而線程并沒有阻塞——他們在忙于響應對方無法恢復工作。這就相當于兩個在走廊相遇的人:Alphonse向他自己的左邊靠想讓Gaston過去,而Gaston向他的右邊靠想讓Alphonse過去??杉親樅碩苑?。Alphonse向他的右邊靠,而Gaston向他的左邊靠,他們還是阻塞了對方。

?;た椋℅uarded Blocks) Top


(本部分原文連接,譯文連接,譯者:Greester,校對:鄭旭東)
多線程之間經常需要協同工作,最常見的方式是使用Guarded Blocks,它循環檢查一個條件(通常初始值為true),直到條件發生變化才跳出循環繼續執行。在使用Guarded Blocks時有以下幾個步驟需要注意:

假設guardedJoy()方法必須要等待另一線程為共享變量joy設值才能繼續執行。那么理論上可以用一個簡單的條件循環來實現,但在等待過程中guardedJoy方法不停的檢查循環條件實際上是一種資源浪費。

public void guardedJoy() {
    // Simple loop guard. Wastes
    // processor time. Don't do this!
    while(!joy) {}
    System.out.println("Joy has been achieved!");
}


更加高效的方法是調用Object.wait將當前線程掛起,直到有另一線程發起事件通知(盡管通知的事件不一定是當前線程等待的事件)。

public synchronized void guardedJoy() {
    // This guard only loops once for each special event, which may not
    // be the event we're waiting for.
    while(!joy) {
        try {
            wait();
        } catch (InterruptedException e) {}
    }
    System.out.println("Joy and efficiency have been achieved!");
}


注意:一定要在循環里面調用wait方法,不要想當然的認為線程喚醒后循環條件一定發生了改變。

和其他可以暫停線程執行的方法一樣,wait方法會拋出InterruptedException,在上面的例子中,因為我們關心的是joy的值,所以忽略了InterruptedException。

為什么guardedJoy是synchronized方法?假設d是用來調用wait的對象,當一個線程調用d.wait,它必須要擁有d的內部鎖(否則會拋出異常),獲得d的內部鎖的最簡單方法是在一個synchronized方法里面調用wait。

當一個線程調用wait方法時,它釋放鎖并掛起。然后另一個線程請求并獲得這個鎖并調用Object.notifyAll通知所有等待該鎖的線程。

public synchronized notifyJoy() {
    joy = true;
    notifyAll();
}


當第二個線程釋放這個該鎖后,第一個線程再次請求該鎖,從wait方法返回并繼續執行。

注意:還有另外一個通知方法,notify(),它只會喚醒一個線程。但由于它并不允許指定哪一個線程被喚醒,所以一般只在大規模并發應用(即系統有大量相似任務的線程)中使用。因為對于大規模并發應用,我們其實并不關心哪一個線程被喚醒。

現在我們使用Guarded blocks創建一個生產者/消費者應用。這類應用需要在兩個線程之間共享數據:生產者生產數據,消費者使用數據。兩個線程通過共享對象通信。在這里,線程協同工作的關鍵是:生產者發布數據之前,消費者不能夠去讀取數據;消費者沒有讀取舊數據前,生產者不能發布新數據。

在下面的例子中,數據通過Drop對象共享的一系列文本消息:

public class Drop {
    // Message sent from producer
    // to consumer.
    private String message;
    // True if consumer should wait
    // for producer to send message,
    // false if producer should wait for
    // consumer to retrieve message.
    private boolean empty = true;

    public synchronized String take() {
        // Wait until message is
        // available.
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = true;
        // Notify producer that
        // status has changed.
        notifyAll();
        return message;
    }

    public synchronized void put(String message) {
        // Wait until message has
        // been retrieved.
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = false;
        // Store message.
        this.message = message;
        // Notify consumer that status
        // has changed.
        notifyAll();
    }
}


Producer是生產者線程,發送一組消息,字符串DONE表示所有消息都已經發送完成。為了模擬現實情況,生產者線程還會在消息發送時隨機的暫停。

import java.util.Random;

public class Producer implements Runnable {
    private Drop drop;

    public Producer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };
        Random random = new Random();

        for (int i = 0;
             i &lt; importantInfo.length;
             i++) {
            drop.put(importantInfo[i]);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
        drop.put("DONE");
    }
}


Consumer是消費者線程,讀取消息并打印出來,直到讀取到字符串DONE為止。消費者線程在消息讀取時也會隨機的暫停。

import java.util.Random;

public class Consumer implements Runnable {
    private Drop drop;

    public Consumer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        Random random = new Random();
        for (String message = drop.take();
             ! message.equals("DONE");
             message = drop.take()) {
            System.out.format("MESSAGE RECEIVED: %s%n", message);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
    }
}


ProducerConsumerExample是主線程,它啟動生產者線程和消費者線程。

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Drop drop = new Drop();
        (new Thread(new Producer(drop))).start();
        (new Thread(new Consumer(drop))).start();
    }
}


注意:Drop類是用來演示Guarded Blocks如何工作的。為了避免重新發明輪子,當你嘗試創建自己的共享數據對象時,請查看Java Collections Framework中已有的數據結構。如需更多信息,請參考Questions and Exercises。

不可變對象 Top



(本部分原文鏈接,譯文鏈接,譯者:Greenster,校對:鄭旭東)
一個對象如果在創建后不能被修改,那么就稱為不可變對象。在并發編程中,一種被普遍認可的原則就是:盡可能的使用不可變對象來創建簡單、可靠的代碼。

在并發編程中,不可變對象特別有用。由于創建后不能被修改,所以不會出現由于線程干擾產生的錯誤或是內存一致性錯誤。

但是程序員們通常并不熱衷于使用不可變對象,因為他們擔心每次創建新對象的開銷。實際上這種開銷常常被過分高估,而且使用不可變對象所帶來的一些效率提升也抵消了這種開銷。例如:使用不可變對象降低了垃圾回收所產生的額外開銷,也減少了用來確保使用可變對象不出現并發錯誤的一些額外代碼。

接下來看一個可變對象的類,然后轉化為一個不可變對象的類。通過這個例子說明轉化的原則以及使用不可變對象的好處。

一個同步類的例子

SynchronizedRGB是表示顏色的類,每一個對象代表一種顏色,使用三個整形數表示顏色的三基色,字符串表示顏色名稱。

public class SynchronizedRGB {

    // Values must be between 0 and 255.
    private int red;
    private int green;
    private int blue;
    private String name;

    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }

    public SynchronizedRGB(int red,
                           int green,
                           int blue,
                           String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }

    public void set(int red,
                    int green,
                    int blue,
                    String name) {
        check(red, green, blue);
        synchronized (this) {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.name = name;
        }
    }

    public synchronized int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }

    public synchronized String getName() {
        return name;
    }

    public synchronized void invert() {
        red = 255 - red;
        green = 255 - green;
        blue = 255 - blue;
        name = "Inverse of " + name;
    }
}


使用SynchronizedRGB時需要小心,避免其處于不一致的狀態。例如一個線程執行了以下代碼:

SynchronizedRGB color =
    new SynchronizedRGB(0, 0, 0, "Pitch Black");
...
int myColorInt = color.getRGB();      //Statement 1
String myColorName = color.getName(); //Statement 2


如果有另外一個線程在Statement 1之后、Statement 2之前調用了color.set方法,那么myColorInt的值和myColorName的值就會不匹配。為了避免出現這樣的結果,必須要像下面這樣把這兩條語句綁定到一塊執行:

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();
}


這種不一致的問題只可能發生在可變對象上。

定義不可變對象的策略

以下的一些規則是創建不可變對象的簡單策略。并非所有不可變類都完全遵守這些規則,不過這不是編寫這些類的程序員們粗心大意造成的,很可能的是他們有充分的理由確保這些對象在創建后不會被修改。但這需要非常復雜細致的分析,并不適用于初學者。

  1. 不要提供setter方法。(包括修改字段的方法和修改字段引用對象的方法)
  2. 將類的所有字段定義為final、private的。
  3. 不允許子類重寫方法。簡單的辦法是將類聲明為final,更好的方法是將構造函數聲明為私有的,通過工廠方法創建對象。
  4. 如果類的字段是對可變對象的引用,不允許修改被引用對象。
                ·不提供修改可變對象的方法。
                ·不共享可變對象的引用。當一個引用被當做參數傳遞給構造函數,而這個引用指向的是一個外部的可變對象時,一定不要保存這個引用。如果必須要保存,那么創建可變對象的拷貝,然后保存拷貝對象的引用。同樣如果需要返回內部的可變對象時,不要返回可變對象本身,而是返回其拷貝。

將這一策略應用到SynchronizedRGB有以下幾步:

  1. SynchronizedRGB類有兩個setter方法。第一個set方法只是簡單的為字段設值(譯者注:刪掉即可),第二個invert方法修改為創建一個新對象,而不是在原有對象上修改。
  2. 所有的字段都已經是私有的,加上final即可。
  3. 將類聲明為final的
  4. 只有一個字段是對象引用,并且被引用的對象也是不可變對象。

經過以上這些修改后,我們得到了ImmutableRGB

final public class ImmutableRGB {

    // Values must be between 0 and 255.
    final private int red;
    final private int green;
    final private int blue;
    final private String name;

    private void check(int red,
                       int green,
                       int blue) {
        if (red < 0 || red > 255
            || green < 0 || green > 255
            || blue < 0 || blue > 255) {
            throw new IllegalArgumentException();
        }
    }

    public ImmutableRGB(int red,
                        int green,
                        int blue,
                        String name) {
        check(red, green, blue);
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.name = name;
    }

    public int getRGB() {
        return ((red << 16) | (green << 8) | blue);
    }

    public String getName() {
        return name;
    }

    public ImmutableRGB invert() {
        return new ImmutableRGB(255 - red,
                       255 - green,
                       255 - blue,
                       "Inverse of " + name);
    }
}

高級并發對象 Top



(本部分原文鏈接,譯文鏈接,譯者:李任
目前為止,該教程重點講述了最初作為Java平臺一部分的低級別API。這些API對于非?;鏡娜撾窶此狄丫愎?,但是對于更高級的任務就需要更高級的API。特別是針對充分利用了當今多處理器和多核系統的大規模并發應用程序。 本節,我們將著眼于Java 5.0新增的一些高級并發特征。大多數特征已經在新的java.util.concurrent包中實現。Java集合框架中也定義了新的并發數據結構。

  • 鎖對象提供了可以簡化許多并發應用的鎖的慣用法。
  • Executors為加載和管理線程定義了高級API。Executors的實現由java.util.concurrent包提供,提供了適合大規模應用的線程池管理。
  • 并發集合簡化了大型數據集合管理,且極大的減少了同步的需求。
  • 原子變量有減小同步粒度和避免內存一致性錯誤的特征。
  • 并發隨機數(JDK7)提供了高效的多線程生成偽隨機數的方法。
1.  鎖對象

同步代碼依賴于一種簡單的可重入鎖。這種鎖使用簡單,但也有諸多限制。

java.util.concurrent.locks包提供了更復雜的鎖。我們不會詳細考察這個包,但會重點關注其最基本的接口,鎖。  鎖對象作用非常類似同步代碼使用的隱式鎖。如同隱式鎖,每次只有一個線程可以獲得鎖對象。通過關聯Condition對象,鎖對象也支持wait/notify機制。 鎖對象之于隱式鎖最大的優勢在于,它們有能力收回獲得鎖的嘗試。如果當前鎖對象不可用,或者鎖請求超時(如果超時時間已指定),tryLock方法會收回獲取鎖的請求。如果在鎖獲取前,另一個線程發送了一個中斷,lockInterruptibly方法也會收回獲取鎖的請求。 讓我們使用鎖對象來解決我們在活躍度中見到的死鎖問題。Alphonse和Gaston已經把自己訓練成能注意到朋友何時要鞠躬。我們通過要求Friend對象在雙方鞠躬前必須先獲得鎖來模擬這次改善。下面是改善后模型的源代碼,Safelock。為了展示其用途廣泛,我們假設Alphonse和Gaston對于他們新發現的穩定鞠躬的能力是如此入迷,以至于他們無法不相互鞠躬。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Random;

public class Safelock {
    static class Friend {
        private final String name;
        private final Lock lock = new ReentrantLock();

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public boolean impendingBow(Friend bower) {
            Boolean myLock = false;
            Boolean yourLock = false;
            try {
                myLock = lock.tryLock();
                yourLock = bower.lock.tryLock();
            } finally {
                if (! (myLock && yourLock)) {
                    if (myLock) {
                        lock.unlock();
                    }
                    if (yourLock) {
                        bower.lock.unlock();
                    }
                }
            }
            return myLock && yourLock;
        }

        public void bow(Friend bower) {
            if (impendingBow(bower)) {
                try {
                    System.out.format("%s: %s has"
                        + " bowed to me!%n",
                        this.name, bower.getName());
                    bower.bowBack(this);
                } finally {
                    lock.unlock();
                    bower.lock.unlock();
                }
            } else {
                System.out.format("%s: %s started"
                    + " to bow to me, but saw that"
                    + " I was already bowing to"
                    + " him.%n",
                    this.name, bower.getName());
            }
        }

        public void bowBack(Friend bower) {
            System.out.format("%s: %s has" +
                " bowed back to me!%n",
                this.name, bower.getName());
        }
}

    static class BowLoop implements Runnable {
        private Friend bower;
        private Friend bowee;

        public BowLoop(Friend bower, Friend bowee) {
            this.bower = bower;
            this.bowee = bowee;
        }

        public void run() {
            Random random = new Random();
            for (;;) {
                try {
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {}
                bowee.bow(bower);
            }
        }
    }

    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new BowLoop(alphonse, gaston)).start();
        new Thread(new BowLoop(gaston, alphonse)).start();
    }
}


2.  執行器(Executors)

在之前所有的例子中,Thread對象表示的線程和Runnable對象表示的線程所執行的任務之間是緊耦合的。這對于小型應用程序來說沒問題,但對于大規模并發應用來說,合理的做法是將線程的創建與管理和程序的其他部分分離開。封裝這些功能的對象就是執行器,接下來的部分將講詳細描述執行器。 

3.  Executor接口

java.util.concurrent中包括三個Executor接口:

  • Executor,一個運行新任務的簡單接口。
  • ExecutorService,擴展了Executor接口。添加了一些用來管理執行器生命周期和任務生命周期的方法。
  • ScheduledExecutorService,擴展了ExecutorService。支持Future和定期執行任務。
通常來說,指向Executor對象的變量應被聲明為以上三種接口之一,而不是具體的實現類。

Executor接口

Executor接口只有一個execute方法,用來替代通常創建(啟動)線程的方法。例如:r是一個Runnable對象,e是一個Executor對象??梢允褂?
e.execute(r);

來代替
(new Thread(r)).start();

但execute方法沒有定義具體的實現方式。對于不同的Executor實現,execute方法可能是創建一個新線程并立即啟動,但更有可能是使用已有的工作線程運行r,或者將r放入到隊列中等待可用的工作線程。(我們將在線程池一節中描述工作線程。)

ExecutorService接口

ExecutorService接口在提供了execute方法的同時,新加了更加通用的submit方法。submit方法除了和execute方法一樣可以接受Runnable對象作為參數,還可以接受Callable對象作為參數。使用Callable對象可以能使任務返還執行的結果。通過submit方法返回的Future對象可以讀取Callable任務的執行結果,或是管理Callable任務和Runnable任務的狀態。 ExecutorService也提供了批量運行Callable任務的方法。最后,ExecutorService還提供了一些關閉執行器的方法。如果需要支持即時關閉,執行器所執行的任務需要正確處理中斷。

ScheduledExecutorService接口

ScheduledExecutorService擴展ExecutorService接口并添加了schedule方法。調用schedule方法可以在指定的延時后執行一個Runnable或者Callable任務。ScheduledExecutorService接口還定義了按照指定時間間隔定期執行任務的scheduleAtFixedRate方法和scheduleWithFixedDelay方法。

4.  線程池

在java.util.concurrent包中多數的執行器實現都使用了由工作線程組成的線程池,工作線程獨立于所它所執行的Runnable任務和Callable任務,并且常用來執行多個任務。 使用工作線程可以使創建線程的開銷最小化。

在大規模并發應用中,創建大量的Thread對象會占用占用大量系統內存,分配和回收這些對象會產生很大的開銷。一種最常見的線程池是固定大小的線程池。這種線程池始終有一定數量的線程在運行,如果一個線程由于某種原因終止運行了,線程池會自動創建一個新的線程來代替它。需要執行的任務通過一個內部隊列提交給線程,當沒有更多的工作線程可以用來執行任務時,隊列保存額外的任務。 使用固定大小的線程池一個很重要的好處是可以實現優雅退化。例如一個Web服務器,每一個HTTP請求都是由一個單獨的線程來處理的,如果為每一個HTTP都創建一個新線程,那么當系統的開銷超出其能力時,會突然地對所有請求都停止響應。如果限制Web服務器可以創建的線程數量,那么它就不必立即處理所有收到的請求,而是在有能力處理請求時才處理。 創建一個使用線程池的執行器最簡單的方法是調用java.util.concurrent.ExecutorsnewFixedThreadPool方法。Executors類還提供了下列一下方法:

  • newCachedThreadPool方法創建了一個可擴展的線程池。適合用來啟動很多短任務的應用程序。
  • newSingleThreadExecutor方法創建了每次執行一個任務的執行器。
  • 還有一些創建ScheduledExecutorService執行器的方法。
如果上面的方法都不滿足需要,可以嘗試java.util.concurrent.ThreadPoolExecutor或者java.util.concurrent.ScheduledThreadPoolExecutor。

5.  Fork/Joint

fork/join框架是ExecutorService接口的一種具體實現,目的是為了幫助你更好地利用多處理器帶來的好處。它是為那些能夠被遞歸地拆解成子任務的工作類型量身設計的。其目的在于能夠使用所有可用的運算能力來提升你的應用的性能。   類似于ExecutorService接口的其他實現,fork/join框架會將任務分發給線程池中的工作線程。fork/join框架的獨特之處在與它使用工作竊取(work-stealing)算法。完成自己的工作而處于空閑的工作線程能夠從其他仍然處于忙碌(busy)狀態的工作線程處竊取等待執行的任務。 fork/join框架的核心是ForkJoinPool類,它是對AbstractExecutorService類的擴展。ForkJoinPool實現了工作偷取算法,并可以執行ForkJoinTask任務。

基本使用方法

使用fork/join框架的第一步是編寫執行一部分工作的代碼。你的代碼結構看起來應該與下面所示的偽代碼類似:

if (當前這個任務工作量足夠小)
    直接完成這個任務
else
    將這個任務或這部分工作分解成兩個部分
    分別觸發(invoke)這兩個子任務的執行,并等待結果


你需要將這段代碼包裹在一個ForkJoinTask的子類中。不過,通常情況下會使用一種更為具體的的類型,或者是RecursiveTask(會返回一個結果),或者是RecursiveAction。 當你的ForkJoinTask子類準備好了,創建一個代表所有需要完成工作的對象,然后將其作為參數傳遞給一個ForkJoinPool實例的invoke()方法即可。

要清晰,先模糊

想要了解fork/join框架的基本工作原理,接下來的這個例子會有所幫助。假設你想要模糊一張圖片。原始的source圖片由一個整數的數組表示,每個整數表示一個像素點的顏色數值。與source圖片相同,模糊之后的destination圖片也由一個整數數組表示。 對圖片的模糊操作是通過對source數組中的每一個像素點進行處理完成的。處理的過程是這樣的:將每個像素點的色值取出,與周圍像素的色值(紅、黃、藍三個組成部分)放在一起取平均值,得到的結果被放入destination數組。因為一張圖片會由一個很大的數組來表示,這個流程會花費一段較長的時間。如果使用fork/join框架來實現這個模糊算法,你就能夠借助多處理器系統的并行處理能力。下面是上述算法結合fork/join框架的一種簡單實現:

public class ForkBlur extends RecursiveAction {
private int[] mSource;
private int mStart;
private int mLength;
private int[] mDestination;

// Processing window size; should be odd.
private int mBlurWidth = 15;

public ForkBlur(int[] src, int start, int length, int[] dst) {
    mSource = src;
    mStart = start;
    mLength = length;
    mDestination = dst;
}

protected void computeDirectly() {
    int sidePixels = (mBlurWidth - 1) / 2;
    for (int index = mStart; index &lt; mStart + mLength; index++) {
        // Calculate average.
        float rt = 0, gt = 0, bt = 0;
        for (int mi = -sidePixels; mi &lt;= sidePixels; mi++) {
            int mindex = Math.min(Math.max(mi + index, 0),
                                mSource.length - 1);
            int pixel = mSource[mindex];
            rt += (float)((pixel &amp; 0x00ff0000) &gt;&gt; 16)
                  / mBlurWidth;
            gt += (float)((pixel &amp; 0x0000ff00) &gt;&gt;  8)
                  / mBlurWidth;
            bt += (float)((pixel &amp; 0x000000ff) &gt;&gt;  0)
                  / mBlurWidth;
        }

        // Reassemble destination pixel.
        int dpixel = (0xff000000     ) |
               (((int)rt) &lt;&lt; 16) |
               (((int)gt) &lt;&lt;  8) |
               (((int)bt) &lt;&lt;  0);
        mDestination[index] = dpixel;
    }
}


接下來你需要實現父類中的compute()方法,它會直接執行模糊處理,或者將當前的工作拆分成兩個更小的任務。數組的長度可以作為一個簡單的閥值來判斷任務是應該直接完成還是應該被拆分。

protected static int sThreshold = 100000;

protected void compute() {
    if (mLength &lt; sThreshold) {
        computeDirectly();
        return;
    }

    int split = mLength / 2;

    invokeAll(new ForkBlur(mSource, mStart, split, mDestination),
              new ForkBlur(mSource, mStart + split, mLength - split,
                           mDestination));
}


如果前面這個方法是在一個RecursiveAction的子類中,那么設置任務在ForkJoinPool中執行就再直觀不過了。通?;嵐韻亂恍┎街瑁?

(1) 創建一個表示所有需要完成工作的任務。

// source image pixels are in src
// destination image pixels are in dst
ForkBlur fb = new ForkBlur(src, 0, src.length, dst);


(2) 創建將要用來執行任務的ForkJoinPool。

ForkJoinPool pool = new ForkJoinPool();


(3) 執行任務。

pool.invoke(fb);


想要瀏覽完成的源代碼,請查看ForkBlur,其中還包含一些創建destination圖片文件的額外代碼。

標準實現

除了能夠使用fork/join框架來實現能夠在多處理系統中被并行執行的定制化算法(如前文中的ForkBlur.java例子),在Java SE中一些比較常用的功能點也已經使用fork/join框架來實現了。在Java SE 8中,java.util.Arrays類的一系列parallelSort()方法就使用了fork/join來實現。這些方法與sort()系列方法很類似,但是通過使用fork/join框架,借助了并發來完成相關工作。在多處理器系統中,對大數組的并行排序會比串行排序更快。這些方法究竟是如何運用fork/join框架并不在本教程的討論范圍內。想要了解更多的信息,請參見Java API文檔。 其他采用了fork/join框架的方法還包括java.util.streams包中的一些方法,此包是作為Java SE 8發行版中Project Lambda的一部分。想要了解更多信息,請參見Lambda Expressions一節。

6.  并發集合

java.util.concurrent包囊括了Java集合框架的一些附加類。它們也最容易按照集合類所提供的接口來進行分類:

  • BlockingQueue定義了一個先進先出的數據結構,當你嘗試往滿隊列中添加元素,或者從空隊列中獲取元素時,將會阻塞或者超時。
  • ConcurrentMapjava.util.Map的子接口,定義了一些有用的原子操作。移除或者替換鍵值對的操作只有當key存在時才能進行,而新增操作只有當key不存在時。使這些操作原子化,可以避免同步。ConcurrentMap的標準實現是ConcurrentHashMap,它是HashMap的并發模式。
  • ConcurrentNavigableMap是ConcurrentMap的子接口,支持近似匹配。ConcurrentNavigableMap的標準實現是ConcurrentSkipListMap,它是TreeMap的并發模式。
  • 所有這些集合,通過 在集合里新增對象和訪問或移除對象的操作之間,定義一個happens-before的關系,來幫助程序員避免內存一致性錯誤。

7.  原子變量

java.util.concurrent.atomic包定義了對單一變量進行原子操作的類。所有的類都提供了get和set方法,可以使用它們像讀寫volatile變量一樣讀寫原子類。就是說,同一變量上的一個set操作對于任意后續的get操作存在happens-before關系。原子的compareAndSet方法也有內存一致性特點,就像應用到整型原子變量中的簡單原子算法。   為了看看這個包如何使用,讓我們返回到最初用于演示線程干擾的Counter類:

class Counter {
    private int c = 0;
    public void increment() {
        c++;
    }

    public void decrement() {
        c--;
    }

    public int value() {
        return c;
    }
}


使用同步是一種使Counter類變得線程安全的方法,如SynchronizedCounter

class SynchronizedCounter {
private int c = 0;
public synchronized void increment() {
c++;
}
public synchronized void decrement() {
c--;
}
public synchronized int value() {
return c;
}
}


對于這個簡單的類,同步是一種可接受的解決方案。但是對于更復雜的類,我們可能想要避免不必要同步所帶來的活躍度影響。將int替換為AtomicInteger允許我們在不進行同步的情況下阻止線程干擾,如AtomicCounter

import java.util.concurrent.atomic.AtomicInteger;
class AtomicCounter {
private AtomicInteger c = new AtomicInteger(0);
public void increment() {
c.incrementAndGet();
}

public void decrement() {
c.decrementAndGet();
}

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


8.  并發隨機數

在JDK7中,java.util.concurrent包含了一個相當便利的類,ThreadLocalRandom,當應用程序期望在多個線程或ForkJoinTasks中使用隨機數時。

對于并發訪問,使用TheadLocalRandom代替Math.random()可以減少競爭,從而獲得更好的性能。

你只需調用ThreadLocalRandom.current(), 然后調用它的其中一個方法去獲取一個隨機數即可。下面是一個例子:

int r = ThreadLocalRandom.current().nextInt(4,77);




評論 共 100 條
100 樓 talingao 2018-10-19 14:45
招java開發工程師,想了解的可以聯系郵箱[email protected]
99 樓 it_node 2018-07-05 19:26
java開發區塊鏈以太坊使用web3j類庫的詳細實戰內容:
web3j教程
98 樓 征途不止 2018-03-17 00:17
面試里面,Java并發問的比較多,已經收藏,好好研究一下。
97 樓 gyyloveyc 2018-03-07 22:02
https://cloud.tencent.com/act/campus/group/detail?group=14954
點此鏈接購買騰訊云服務器,配置“1核2G 1M帶寬  50G云硬盤”,16個月只需120元
購買后通過以下鏈接續費兩年(認證隨便填填就好),120元一年。
https://cloud.tencent.com/act/campus
96 樓 Faith-123 2017-09-25 10:38
總結全面,點贊
95 樓 mfkujjisk 2017-08-10 20:03
阿里巴巴招聘java工程師,大平臺,期待你加入,簡歷請發到[email protected]
94 樓 1156911356 2017-07-06 11:23
mark
93 樓 dfjjfxyl 2017-07-04 16:52
開源項目推薦網站:
//binlily.imwork.net
92 樓 liujiaoshui 2017-04-10 11:22
只能算科普吧。。。
91 樓 一個橘子 2016-10-31 19:40
不錯,我感覺能集成Oracle的軟件都很牛逼
90 樓 zftzyw 2016-05-31 15:45
 
89 樓 zftzyw 2016-05-31 15:47
  
88 樓 極品歡神 2016-04-19 09:50
引用
    
87 樓 dream_land 2016-03-30 13:03
mark,收藏
86 樓 nickli1992 2016-03-20 22:43
smallbug_vip 寫道
8.原子訪問

有一句:
      對所有聲明為volatile的變量(包括long和double變量)的讀寫是原子的。

volatile可以保證變量狀態對當前線程和其他線程可見,和避免重排序。貌似不能保證原子操作,難道是我哪里理解有誤?還請大牛指點。


翻了下JSR,里面有一句“a write to a volatile field happens before every subsequent read of that same volatile”。內存模型已經明確說明寫和讀之間有happens before關系,具體怎么實現的還是應該看看源碼,可能用到了某種鎖機制?
85 樓 nickli1992 2016-03-20 22:24
線程池這里講的不是很詳細啊,滾去翻文檔吧。
84 樓 smallbug_vip 2016-03-08 23:36
8.原子訪問

有一句:
      對所有聲明為volatile的變量(包括long和double變量)的讀寫是原子的。

volatile可以保證變量狀態對當前線程和其他線程可見,和避免重排序。貌似不能保證原子操作,難道是我哪里理解有誤?還請大牛指點。
83 樓 lopato9 2016-02-17 11:25
     
82 樓 lizewu 2016-02-14 17:59
詳細,清晰,不錯
81 樓 qq342806869 2016-01-14 15:19
mark??!
80 樓 esaka 2015-11-12 09:35
mark!!!
79 樓 facingSun 2015-11-04 09:23
寫的好,贊一個~~~~
78 樓 krystal_0424 2015-11-03 16:57
這是翻譯嗎.mark
77 樓 1554312244 2015-11-03 10:09
mark~~
76 樓 tonyyan 2015-09-01 15:26
謝謝分享!
75 樓 1779843209 2015-08-27 10:00
zhuzhiguosnail 寫道
寫的不錯,  詳細

74 樓 mangguo 2015-08-19 15:22
頂頂頂?。?!mark。
大家也可以看看我寫的java小教程
73 樓 handong890 2015-07-12 14:05
這都是老版本的啊,現在完全都洗牌了,建議大家不要看了。
看 java.util.concurrent 相關
72 樓 wenjing3230 2015-06-21 22:23
不錯 收藏
71 樓 txwh_yj 2015-06-15 14:12
值得收藏一下

發表評論

您還沒有登錄,請您登錄后再發表評論

相關推薦

Global site tag (gtag.js) - Google Analytics