Thinking in Java -- 并发（一）

并发的多面性

---

基本的并发

定义任务

线程可以驱动任务，我们通过实现 Runnable 接口来提供，需要实现 Runnable 接口的 run() 方法。

package concurrency;

/**
 * Created by wwh on 16-3-24.
 */
public class LiftOff implements Runnable {
    protected int countDown = 10;
    private static int taskCount = 0;
    private final int id = taskCount++;
    public LiftOff() {}
    public LiftOff(int countDown) {
        this.countDown = countDown;
    }
    public String status() {
        return "#" + id + "(" +
                (countDown > 0 ? countDown : "LiftOff!") + "), ";
    }

    public void run() {
        while (countDown-- > 0) {
            System.out.println(status());
            /* Thread.yield() 是对线程调度器的一种建议，可以将CPU从一个线程转移给另一个线程 */
            Thread.yield();
        }
    }
}

package concurrency;

/**
 * Created by wwh on 16-3-24.
 */
public class MainThread {
    public static void main(String[] args) {
        LiftOff lauch = new LiftOff();
        lauch.run();
    }
}

我们也可以通过继承 Thread 类覆盖 run() 方法来实现线程类，但继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承。而且实现 Runnable 接口适合多线程共享资源，继承 Thread 类适合各个线程完成自己的任务，因为继承 Thread 类相当于每个线程有一份各自的资源，而实现 Runnable 还可以让多个线程共享一份代码，具体戳这里。

---

Thread 类

将 Runnable 对象转变为工作任务的传统方式是将它提交给一个 Thread 构造器。

public class BasicThreads {
    public static void main(String[] args) {
        for (int i = 0; i < 5; ++i) {
            new Thread(new LiftOff()).start();
        }
        System.out.println("Waiting for LiftOff");
    }
}

Thread 构造器只需要一个 Runnable 对象。调用 Thread 对象的 start() 方法为该线程执行必须的初始化操作，然后内部调用 Runnable 的 run() 方法。

---

使用 Executor

Java SE5 并发包中引入执行器可以为我们管理线程 Thread 对象。

package concurrency;

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

/**
 * Created by wwh on 16-3-24.
 */
public class CachedThreadPool {
    public static void main(String []args) {
        /* ExecutorServive 是具有声明周期的 Executor */
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; ++i) {
            exec.execute(new LiftOff());
        }
        /* shutdown 被用来防止新任务被提交给 Executor */
        exec.shutdown();
    }
}

ThreadPool 种类很多。如下图：

包括
CacheThreadPool：为每个任务都创建一个线程
FixedThreadPool：一次性预先分配好固定大小的线程
SingleThreadExecutor：线程数唯一，提交多个任务会排队等候
ScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。

---

从任务中产生返回值

如果我们希望任务完成时能够返回一个值，那么可以实现 Callable 接口而不是 Runnable 接口，实现 Callable 接口要求覆盖 Call() 方法。

package concurrency;

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

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

class TaskWithResult implements Callable<String> {
    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<Future<String>> results =
                new ArrayList<Future<String>>();
        for (int i = 0; i < 10; ++i) {
            /* submit() 方法会产生 Future 对象，可以通过 Future 对象的 isDone() 方法来判断查询 Future 是否已经完成，当完成时，可以使用 get() 方法获取结果 */
            results.add(exec.submit(new TaskWithResult(i)));
        }
        for (Future<String> 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：可重入锁，允许尝试着去获取锁。

这几种方式后续会详细解释。