Thinking in Java from Chapter 21

时间：2022-04-25 15:47:46

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),

*/

这与从Thread继承并没有什么特别的差异，只是语法稍微晦涩一些。但是，实现接口使得你可以继承另一个不同的类，而从Thread继承将不行。

注意，这个示例中的start()是在构造器中调用的。应该意识到，在构造器中启动线程可能会变得很有问题，因为另一个任务可能会在构造器结束之前开始执行，这意味着该任务能够访问处于不稳定状态的对象。这是优选Executor而不是显式地创建Thread对象的另一个原因。

有时，通过使用内部类来讲线程代码隐藏在类中将会很有用：

相关文章