package concurrency;

import java.util.ArrayList;
import java.util.concurrent.*;

/**
 * Created by wwh on 16-3-24.
 */

class TaskWithResult implements Callable {
    private int id;
    public TaskWithResult(int id) {
        this.id = id;
    }
    public String call() throws Exception {
        return "reslut of TaskWithResult " + id;
    }
}

public class CallableDemo {
    public static void main(String []args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        /* 定義 Future 對象，在將來獲取 */
        ArrayList> results =
                new ArrayList>();
        for (int i = 0; i < 10; ++i) {
            /* submit() 方法會產生 Future 對象，可以通過 Future 對象的 isDone() 方法來判斷查詢 Future 是否已經完成，當完成時，可以使用 get() 方法獲取結果 */
            results.add(exec.submit(new TaskWithResult(i)));
        }
        for (Future fs : results) {
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } finally {
                exec.shutdown();
            }
        }
    }
}

優先級

線程的優先級將該線程的重要性傳遞給了調度器。調度器會傾向於讓優先級高的線程先運行。

package concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by wwh on 16-3-24.
 */
public class SimplePriorities implements Runnable {
    private int countDown = 5;
    private volatile double d;
    private int priority;

    public SimplePriorities(int priority) {
        this.priority = priority;
    }
    public String toString() {
        return Thread.currentThread() + ": " + countDown;
    }

    public void run() {
        Thread.currentThread().setPriority(priority);
        while (true) {
            /* 這裡只有循環次數比較大才能看出優先級的優勢 */
            for (int i = 0; i < 100000000; ++i) {
                d += (Math.PI + Math.E) / (double)i;
                if (i % 1000 == 0) {
                    Thread.yield();
                }
            }
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; ++i) {
            exec.execute(new SimplePriorities(Thread.MIN_PRIORITY));
        }
        exec.execute(new SimplePriorities(Thread.MAX_PRIORITY));
        exec.shutdown();
    }
}

加入一個線程

一個線程可以在其他線程之上調用 join() 方法，其效果是等待一段時間直到第二個線程結束才繼續執行。join() 調用時可以攜帶超時參數。

package concurrency;

/**
 * Created by wwh on 16-3-24.
 */

class Sleeper extends Thread {
    private int duration;
    public Sleeper(String name, int sleepTime) {
        super(name);
        duration = sleepTime;
        start();
    }
    public void run() {
        try {
            sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println(getName() + " was interrupted. " +
            "isInterrupted(): " + isInterrupted());
            return;
        }
        System.out.println(getName() + " has awakened");
    }
}

class Joiner extends Thread {
    private Sleeper sleeper;
    public Joiner(String name, Sleeper sleeper) {
        super(name);
        this.sleeper = sleeper;
        start();
    }
    public void run() {
        try {
            /* 等待線程 */
            sleeper.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Interrupted");
        }
        System.out.println(getName() + " join completed");
    }
}

public class Joining {
    public static void main(String[] args) {
        Sleeper
                sleepy = new Sleeper("Sleepy", 1500),
                grumpy = new Sleeper("Grumpy", 1500);
        Joiner
                drpey = new Joiner("Dopey", sleepy),
                doc = new Joiner("Doc", grumpy);
        grumpy.interrupt();

    }
}

共享受限資源

多個線程可能出現訪問共享資源的情況。

package concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by wwh on 16-4-7.
 */
public class Counter implements Runnable {
    private static int counter = 0;
    public static int getCounter() {
        return counter;
    }
    public void run() {
        for (int i = 0; i < 1000000; ++i) {
            counter++;
        }
    }
    public static void test(int n) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < n; ++i) {
            executorService.execute(new Counter());
        }
        executorService.shutdown();
    }

    public static void main(String[] args) throws InterruptedException {
        Counter.test(10);
        System.out.println(Counter.getCounter());
    }

}

以上代碼沒有進行同步，多個線程同時增加計數器。所以導致結果不正確。

Java 為我們提供了幾種方式。

synchronzied：包括兩種用法，synchronzied 方法和 synchronized 塊。對於有 synchronzied 關鍵字修飾的類方法或代碼塊，執行時首先要獲取該類實例的鎖，執行完畢後釋放。在執行過程中要有其它線程等請求該 synchronzied 方法或代碼塊則被阻塞。
Lock：互斥鎖，顯示鎖對象。Lock 對象必須被顯式創建、鎖定和釋放。
ReentrantLock：可重入鎖，允許嘗試著去獲取鎖。

這幾種方式後續會詳細解釋。