Thinking in Java from Chapter 21

From Thinking in Java 4th Edition

并发

线程可以驱动任务，因此你需要一种描述任务的方式，这可由Runnable接口来提供。

要想定义任务，只需要实现Runnable接口，并编写run()方法，使得该任务可以执行你的命令。

public class LiftOff implements Runnable {
    protected int countDown = 10;   // Default
    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();
        }
    }
}

从Runnable导出一个类时，它必须具有run()方法，但是它不会产生任何内在的线程能力。要实现线程行为，你必须显式地将一个任务附着到线程上。

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

public class BasicThread {
    public static void main(String[] args){
        Thread t = new Thread(new LiftOff());
        t.start();
        System.out.println("Waiting for LiftOff");
    }
} /* Output:
Waiting for LiftOff
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(LiftOff!), 
*/

Thread构造器只需要一个Runnable对象。

1. 调用Thread对象的start()方法为该线程执行必要的初始化操作。

2. 调用Runnable对象的run()方法，以便在这个新线程中启动该任务。

从输出可以看出start()方法迅速返回了，因为"Waiting for LiftOff"消息在倒计时完成之前就出现了。

实际上你产生的是对LiftOff.run()方法的调用，并且这个方法还没完成，但是因为LiftOff.run()是由不同的线程执行的，因此你仍旧可以执行main()线程中的其他操作。

如果添加更多的线程去驱动更多的任务，就可以看到所有任务彼此之间是如何呼应的：

public class MoreBasicThreads {
    public static void main(String[] args){
        for(int i = 0; i < 5; ++i)
            new Thread(new LiftOff()).start();
        System.out.println("Waiting for LiftOff");
    }
} /* Output:
Waiting for LiftOff
#3(9), #1(9), #3(8), #1(8), #3(7), #1(7), #1(6), #1(5), 
#1(4), #1(3), #1(2), #1(1), #1(LiftOff!), #4(9), #4(8), 
#4(7), #4(6), #2(9), #2(8), #2(7), #2(6), #2(5), #2(4), 
#2(3), #2(2), #2(1), #2(LiftOff!), #0(9), #4(5), #3(6), 
#4(4), #3(5), #4(3), #3(4), #4(2), #3(3), #4(1), #3(2), 
#4(LiftOff!), #0(8), #3(1), #0(7), #3(LiftOff!), #0(6), 
#0(5), #0(4), #0(3), #0(2), #0(1), #0(LiftOff!),
*/

使用Executor

Executor在客户端和任务执行之间提供了一个间接层；与客户端直接执行任务不同，这个中介对象将执行任务。

Executor用来代替MoreBasicThreads.java中显式创建Thread对象。

ExecutorService知道如何构建上下文来执行Runnable对象。

import java.util.concurrent.*;
 
public class CachedThreadPool {
    public static void main(String[] args){
        ExecutorService exec = Executors.newCachedThreadPool();   // No space between new and Cached
        for(int i = 0; i < 5; ++i)
            exec.execute(new LiftOff());
        exec.shutdown();
    }
} /* Output:
#0(9), #2(9), #0(8), #1(9), #0(7), #0(6), #0(5), #0(4), 
#0(3), #0(2), #0(1), #0(LiftOff!), #2(8), #1(8), #3(9), 
#2(7), #1(7), #3(8), #2(6), #1(6), #3(7), #2(5), #2(4), 
#4(9), #3(6), #1(5), #3(5), #1(4), #1(3), #1(2), #1(1), 
#1(LiftOff!), #4(8), #2(3), #4(7), #4(6), #3(4), #4(5), 
#3(3), #4(4), #3(2), #4(3), #3(1), #4(2), #2(2), #4(1), 
#4(LiftOff!), #3(LiftOff!), #2(1), #2(LiftOff!),
*/

上例中，CachedThreadPool将为每个任务都创建一个线程。

ExecutorService对象是使用静态的Executor方法创建的，这个方法可以确定其Executor类型。

常见的情况是，Executor被用来创建和管理系统中的所有的任务。

对shutdown()方法的调用可以防止新任务被提交给这个Executor，当前任务(本例中为main的线程)将继续运行在shutdown()被调用之前提交的所有任务。

下面的程序展示了CachedThreadPool替换为不同类型的Executor。FixedThreadPool使用了有限的线程集来执行所提交的任务

import java.util.concurrent.*;
 
public class FixedThreadPool {
    public static void main(String[] args){
        // Constructor argument is number of threads:
        ExecutorService exec = Executors.newFixedThreadPool(5);
        for(int i = 0; i < 5; ++i)
            exec.execute(new LiftOff());
        exec.shutdown();
    }
} /* Output:
#0(9), #2(9), #4(9), #0(8), #2(8), #3(9), #1(9), #1(8), 
#0(7), #4(8), #0(6), #4(7), #0(5), #4(6), #4(5), #4(4), 
#4(3), #4(2), #4(1), #4(LiftOff!), #1(7), #1(6), #1(5), 
#1(4), #1(3), #1(2), #1(1), #1(LiftOff!), #3(8), #2(7), 
#0(4), #3(7), #2(6), #0(3), #3(6), #2(5), #0(2), #3(5), 
#0(1), #3(4), #2(4), #0(LiftOff!), #3(3), #2(3), #3(2), 
#2(2), #3(1), #2(1), #3(LiftOff!), #2(LiftOff!),
*/

有了FixedThreadPool，你就可以一次性预先执行代价高昂的线程分配。这可以节省时间，因为你不用为每个任务都固定地付出创建线程的开销。

SingleThreadExecutor就像是线程数量为1的FixedThreadPool。如果向SingleThreadExecutor提交了多个任务，那么这些任务将排队，每个任务都会在下一个任务开始之前结束，所有的任务将使用相同的线程。

下例中可以看到每个任务都是按照它们被提交的顺序、并且是在下一个任务开始之前完成的。因此SingleThreadExecutor会序列化所有提交给它们的任务，并会维护它自己（隐藏）的悬挂任务。

import java.util.concurrent.*;
 
public class SingleThreadExecutor {
    public static void main(String[] args){
        ExecutorService exec = Executors.newSingleThreadExecutor();
         
        for(int i = 0; i < 5; ++i)
            exec.execute(new LiftOff());
        exec.shutdown();
    }
} /* Output:
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(LiftOff!), 
#1(9), #1(8), #1(7), #1(6), #1(5), #1(4), #1(3), #1(2), #1(1), #1(LiftOff!), 
#2(9), #2(8), #2(7), #2(6), #2(5), #2(4), #2(3), #2(2), #2(1), #2(LiftOff!), 
#3(9), #3(8), #3(7), #3(6), #3(5), #3(4), #3(3), #3(2), #3(1), #3(LiftOff!), 
#4(9), #4(8), #4(7), #4(6), #4(5), #4(4), #4(3), #4(2), #4(1), #4(LiftOff!),
*/

从任务中返回值

Runnable是执行工作的独立任务，但是它不返回任何值。如果希望能够返回值，则必须实现Callable接口而不是Runnable接口。

Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它：

import java.util.concurrent.*;
import java.util.*;
 
class TaskWithResult implements Callable<String> {
    private int id;
    public TaskWithResult(int id){
        this.id = id;
    }
     
    public String call() {
        return "result of TaskWithResult " + id;
    }
}
 
public class CallableDemo {
    public static void main(String[] args){
        ExecutorService exec = Executors.newCachedThreadPool();
        ArrayList<Future<String>> results = new ArrayList<Future<String>>();
         
        for(int i = 0; i < 10; ++i)
            results.add(exec.submit(new TaskWithResult(i)));
        for(Future<String> fs : results)
            try {
                // get() blocks until completion:
                System.out.println(fs.get());
            } catch(InterruptedException e){
                System.out.println(e);
                return;
            } catch(ExecutionException e) {
                System.out.println(e);
            } finally {
                exec.shutdown();
            }
    }
} /* Output:
result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9
*/

submit()方法会产生Future对象，它用Callable返回结果的特定类型进行了参数化。

1. 可以用isDone()方法来查看Future是否完成

2. 任务完成时，可以调用get()方法来获取该结果

也可以不用isDone()进行检查就直接调用get()，这种情况下，get()将阻塞直至结果准备就绪。

休眠

影响任务行为的一种简单方法是调用sleep()，这将使任务中止执行给定的时间。

在LiftOff类中，把yield()的调用换成sleep()将得到：

import java.util.concurrent.*;
 
public class SleepingTask extends LiftOff {
    public void run(){
        try {
            while(countDown-- > 0){
                System.out.print(status());
                // Old-style
                // Thread.sleep(100);
                // Java SE5/6-style:
                TimeUnit.MILLISECONDS.sleep(100);
            }
        } catch(InterruptedException e) {
            System.err.println("Interrupted");
        }
    }
     
    public static void main(String[] args){
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; ++i)
            exec.execute(new SleepingTask());
        exec.shutdown();
    }
} /* Output:
#0(9), #3(9), #1(9), #4(9), #2(9), 
#0(8), #3(8), #1(8), #2(8), #4(8), 
#0(7), #4(7), #2(7), #3(7), #1(7), 
#4(6), #0(6), #3(6), #1(6), #2(6), 
#4(5), #3(5), #2(5), #0(5), #1(5), 
#4(4), #3(4), #2(4), #1(4), #0(4), 
#4(3), #2(3), #3(3), #0(3), #1(3), 
#4(2), #2(2), #0(2), #3(2), #1(2), 
#4(1), #2(1), #0(1), #3(1), #1(1), 
#4(LiftOff!), #2(LiftOff!), #0(LiftOff!), #3(LiftOff!), #1(LiftOff!),
*/

sleep()调用可以抛出InterruptedException异常，并可以看到，它在run()中捕获。因为异常不能跨线程传播回main()，所以你必须在本地处理所有在任务内部产生的异常。

优先级

调度器将倾向于让优先权最高的线程先执行，然而，这并不意味着优先权较低的线程将得不到执行（也就是说，优先权不会导致死锁）。优先级较低的线程仅仅是执行的频率较低。

绝大多数时间里，所有线程都应该按照默认的优先级运行。试图操纵线程的优先级通常是一种错误。

可以用getPriority()来读取现有线程的优先级，并且在任何时候都可以通过setPriority()来修改它：

import java.util.concurrent.*;
 
public class SimplePriorities implements Runnable {
    private int countDown = 5;
    private volatile double d;  // No optimization
    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){
            // An expensive, interruptable operation:
            for(int i = 1; i < 100000; ++i){
                d += (Math.PI + Math.E) / (double)i;
                if(0 == i % 1000)
                    Thread.yield();
            }
             
            System.out.println(this);
            if(0 == --countDown) 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();
    }
}

让步

如果知道已经完成了在run()方法的循环的一次迭代过程中所需的工作，就可以给线程调度机制一个暗示：你的工作已经做得差不多了，可以让别的线程使用CPU了。这个暗示将通过yield()方法做出（不过这只是一个暗示，没有任何机制保证它将会被采纳）。

当调用yield()时，你也在建议具有相同优先级的其他线程可以运行。

后台线程

后台(daemon)线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可缺少的部分。

当所有非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。

反过来，只要有非后台线程还在运行，程序就不会终止：

import java.util.concurrent.*;
import static net.mindview.util.Print.*;
 
public class SimpleDaemons implements Runnable {
    public void run(){
        try {
            while(true) {
                TimeUnit.MILLISECONDS.sleep(100);
                print(Thread.currentThread() + " " + this);
            }
        } catch(InterruptedException e) {
            print("sleep() interrupted");
        }
    }
     
    public static void main(String[] args) throws Exception {
        for(int i = 0; i < 10; ++i){
            Thread daemon = new Thread(new SimpleDaemons());
            daemon.setDaemon(true); // Must call before start()
            daemon.start();
        }
         
        print("All daemons started");
        TimeUnit.MILLISECONDS.sleep(175);
    }
} /* Output:
All daemons started
Thread[Thread-4,5,main] SimpleDaemons@187a0b5
Thread[Thread-2,5,main] SimpleDaemons@153c85c
Thread[Thread-3,5,main] SimpleDaemons@23fc9c
Thread[Thread-8,5,main] SimpleDaemons@b211be
Thread[Thread-0,5,main] SimpleDaemons@11f65e4
Thread[Thread-1,5,main] SimpleDaemons@15332f2
Thread[Thread-9,5,main] SimpleDaemons@1da14a7
Thread[Thread-7,5,main] SimpleDaemons@16b9e5b
Thread[Thread-5,5,main] SimpleDaemons@1bbee70
Thread[Thread-6,5,main] SimpleDaemons@1cbca8d
*/

SimpleDaemons.java创建了显示的线程，以便可以设置它们的后台标志。通过编写定制的ThreadFactory可以定制由Executor创建的线程的属性(后台、优先级、名称)：

package net.mindview.util;
import java.util.concurrent.*;
 
public class DaemonThreadFactory implements ThreadFactory {
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
}

现在可以用一个新的DaemonThreadFactory作为参数传递给Executor.newCachedThreadPool()：

package net.mindview.util;
import java.util.concurrent.*;
 
public class DaemonThreadFactory implements ThreadFactory {
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
}
 
 
// Using a Thread Factory to create daemons.
import java.util.concurrent.*;
import net.mindview.util.*;
import static net.mindview.util.Print.*;
 
public class DaemonFromFactory implements Runnable {
    public void run(){
        try {
            while(true){
                TimeUnit.MILLISECONDS.sleep(100);
                print(Thread.currentThread() + " " + this);
            }
        } catch(InterruptedException e){
            print("Interrupted");
        }
    }
     
    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executor.newCachedThreadPool(new DaemonThreadFactory());
        for(int i = 0; i < 10; ++i)
            exec.execute(new DaemonFromFactory());
        print("All daemons started");
        TimeUnit.MILLISECONDS.sleep(500);   // Run for a while
    }
} /* Output
All daemons started
Thread[Thread-0,5,main] DaemonFromFactory@c01009
Thread[Thread-9,5,main] DaemonFromFactory@1bd343
Thread[Thread-7,5,main] DaemonFromFactory@7c321a
Thread[Thread-5,5,main] DaemonFromFactory@c79e29
Thread[Thread-3,5,main] DaemonFromFactory@279922
Thread[Thread-1,5,main] DaemonFromFactory@1fcb7ef
Thread[Thread-8,5,main] DaemonFromFactory@7e3dfb
Thread[Thread-2,5,main] DaemonFromFactory@1415cb9
Thread[Thread-4,5,main] DaemonFromFactory@334426
Thread[Thread-6,5,main] DaemonFromFactory@15226d3
Thread[Thread-0,5,main] DaemonFromFactory@c01009
Thread[Thread-9,5,main] DaemonFromFactory@1bd343
....
*/

每个静态的ExecutorService创建方法都被重载为接受一个ThreadFactory对象，而这个对象将被用来创建新的线程：

package net.mindview.util;
import java.util.concurrent.*;
 
public class DaemonThreadPoolExecutor extends ThreadPoolExecutor {
    public DaemonThreadPoolExecutor() {
        super(0, Integer.MAX_VALUE, 60L, TimeUnit, SECONDS, new SynchronousQueue<Runnable>(), new DaemonThradFactory());
    }
}

可以通过iDaemon()方法来确定线程是否是一个后台线程。如果是一个后台线程，那么它创建的任何线程将自动被设置成后台线程。

// Daemon threads spawn other daemon threads.
import java.util.concurrent.*;
import static net.mindview.util.Print.*;
 
class Daemon implements Runnable {
    private Thread[] t = new Thread[10];
     
    public void run() {
        for(int i = 0; i < t.length; ++i){
            t[i] = new Thread(new DaemonSpawn());
            t[i].start();
            printnb("DaemonSpawn " + i + " started, ");
        }
         
        for(int i = 0; i < t.length; ++i)
            printnb("t[" + i + "].isDaemon() = " + t[i].isDaemon() + ", ");
         
        while(true)
            Thread.yield();
    }
}
 
class DaemonSpawn implements Runnable {
    public void run(){
        while(true)
            Thread.yield();
    }
}
 
public class Daemons {
    public static void main(String[] args) throws Exception {
        Thread d = new Thread(new Daemon());
        d.setDaemon(true);
        d.start();
        printnb("d.isDaemon() = " + d.isDaemon() + ", ");
         
        // Allow the daemon threads to 
        // finish their startup processes:
        TimeUnit.SECONDS.sleep(1);
    }
} /* Output:
d.isDaemon() = true, 
DaemonSpawn 0 started, 
DaemonSpawn 1 started, 
DaemonSpawn 2 started, 
DaemonSpawn 3 started, 
DaemonSpawn 4 started, 
DaemonSpawn 5 started, 
DaemonSpawn 6 started, 
DaemonSpawn 7 started, 
DaemonSpawn 8 started, 
DaemonSpawn 9 started, 
t[0].isDaemon() = true, 
t[1].isDaemon() = true, 
t[2].isDaemon() = true, 
t[3].isDaemon() = true, 
t[4].isDaemon() = true, 
t[5].isDaemon() = true, 
t[6].isDaemon() = true, 
t[7].isDaemon() = true, 
t[8].isDaemon() = true, 
t[9].isDaemon() = true,
*/

应该意识到后台进程在不执行finally子句的情况下就会终止其run()方法：

// Daemon threads don't run the finally clause
import java.util.concurrent.*;
import static net.mindview.util.Print.*;
 
class ADaemon implements Runnable {
    public void run() {
        try {
            print("Starting ADaemon");
            TimeUnit.SECONDS.sleep(1);
        } catch(InterruptedException e){
            print("Exiting via InterruptedException");
        } finally {
            print("This should always run?");
        }
    }
}
 
public class DaemonsDontRunFinally {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(new ADaemon());
        t.setDaemon(true);
        t.start();
    }
} /* Output:
Starting ADaemon
*/

目前的示例中，都是实现了Runnable。在非常简单的情况下，你可能会希望使用直接从Thread继承这种可替换的方式：

public class SimpleThread extends Thread {
    private int countDown = 5;
    private static int threadCount = 0;
     
    public SimpleThread() {
        // Store the thread name:
        super(Integer.toString(++threadCount));
        start();
    }
     
    public String toString() {
        return "#" + getName() + "(" + countDown + "), ";
    }
     
    public void run() {
        while(true){
            System.out.print(this);
            if(0 == --countDown)
                return;
        }
    }
     
    public static void main(String[] args){
        for(int i = 0; i < 5; ++i)
            new SimpleThread();
    }
} /* Output:
#2(5), #2(4), #2(3), #2(2), #2(1), 
#4(5), #4(4), #4(3), #4(2), #4(1), 
#5(5), #5(4), #5(3), #5(2), #5(1), 
#3(5), #3(4), #3(3), #3(2), #3(1), 
#1(5), #1(4), #1(3), #1(2), #1(1),
*/

你可以通过适当的Thread构造器为Thread对象赋予具体的名称，这个名称可以通过使用getName()从toString()中获得。

另一种可能会看到的惯用法是自管理的Runnable:

// A Runnable containing its own driver Thread.
public class SelfManaged implements Runnable {
    private int countDown = 5;
    private Thread t = new Thread(this);
     
    public SelfManaged() {t.start();}
     
    public String toString() {
        return Thread.currentThread().getName() + "(" + countDown + "), ";
    }
     
    public void run() {
        while(true){
            System.out.print(this);
            if(0 == --countDown)
                return;
        }
    }
     
    public static void main(String[] args){
        for(int i = 0; i < 5; ++i)
            new SelfManaged();
    }
} /* Output:
Thread-3(5), Thread-3(4), Thread-3(3), Thread-3(2), Thread-3(1), 
Thread-5(5), Thread-5(4), Thread-5(3), Thread-5(2), Thread-5(1), 
Thread-6(5), Thread-6(4), Thread-6(3), Thread-6(2), Thread-6(1), 
Thread-4(5), Thread-4(4), Thread-4(3), Thread-4(2), Thread-4(1), 
Thread-7(5), Thread-7(4), Thread-7(3), Thread-7(2), Thread-7(1),
*/