Java的并发（二）

从任务中产生返回值

Runnable是执行工作的独立任务，但是它不返回任何值。如果你希望任务在完成时能够返回一个值，那么可以实现Callable接口而是不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()而不是run()中返回的值，并且必须使用ExecutorService.submit()方法调用它，下面是一个简单示例。

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

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 {
				System.out.println(fs.get());
			} catch (InterruptedException e) {
				System.out.println(e);
				return;
			} catch (ExecutionException e) {
				System.out.println(e);
			} finally {
				exec.shutdown();
			}
		}
	}
}
/*
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返回结果的特定类型进行了参数化。你可以用isDone()方法来查询Future是否已经完成。当任务完成时，它具有一个结果，可以调用get()方法来获取该结果。你也可以不用isDone()进行检查就直接调动get()，在这种情况下，get()将阻塞，直至结果准备就绪。你还可以在试图调用get()来获取结果之前，先调用具有超时的get()，或者调用isDone()来查看任务是否完成。

休眠

影响任务行为的一种简单方法是调用sleep()，这将使任务中止执行给定的时间。在LiftOff类中，要是把对yield()的调用换成是调用sleep()，将得到如下结果：

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

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.out.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();
	}
}
/*
#1(9),#4(9),#0(9),#2(9),#3(9),#1(8),#3(8),#4(8),#2(8),#0(8),#2(7),#4(7),#0(7),#3(7),#1(7),#0(6),#4(6),#2(6),#3(6),#1(6),#2(5),#3(5),#4(5),#1(5),#0(5),#4(4),#1(4),#0(4),#3(4),#2(4),#1(3),#2(3),#3(3),#4(3),#0(3),#0(2),#1(2),#2(2),#4(2),#3(2),#0(1),#1(1),#2(1),#3(1),#4(1),#3(Liftoff!),#2(Liftoff!),#4(Liftoff!),#0(Liftoff!),#1(Liftoff!),
*/

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

在每个打印语句后，每个任务都将要睡眠（阻塞），这使得线程调度器可以切换到另一个线程，进而驱动另一个任务。但是，顺序行为依赖于底层的线程机制，这种机制在不同的操作系统之间是有差异的，因此，你不能依赖于它。如果你必须控制任务执行的顺序，那么最好的办法就是使用同步控制，或者在某些情况下压根不使用进程，但是要编写自己的协作例程，这些例程将会按照指定的顺序在互相之间传递控制权。

优先级

线程的优先级将现成的重要性传递给了调度器。尽管CPU处理现有线程集的顺序是不确定的，但是调度器将倾向于让优先度最高的线程先执行。然而，这并不是意味着优先权较低的的线程将得不到执行（即优先权不会导致死锁）。优先级较低的线程仅仅是执行的频率较低。

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

以下示例演示优先级等级，可以用getPriority()来获取现有线程的优先级，并且在任何时候都可以通过setPriority()来修改它。

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


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=1;i<10000;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();
	}
}
/*
Thread[pool-1-thread-6,10,main]: 5
Thread[pool-1-thread-4,1,main]: 5
Thread[pool-1-thread-5,1,main]: 5
Thread[pool-1-thread-1,1,main]: 5
Thread[pool-1-thread-2,1,main]: 5
Thread[pool-1-thread-3,1,main]: 5
Thread[pool-1-thread-6,10,main]: 4
Thread[pool-1-thread-6,10,main]: 3
Thread[pool-1-thread-1,1,main]: 4
Thread[pool-1-thread-4,1,main]: 4
Thread[pool-1-thread-5,1,main]: 4
Thread[pool-1-thread-2,1,main]: 4
Thread[pool-1-thread-3,1,main]: 4
Thread[pool-1-thread-6,10,main]: 2
Thread[pool-1-thread-6,10,main]: 1
Thread[pool-1-thread-2,1,main]: 3
Thread[pool-1-thread-1,1,main]: 3
Thread[pool-1-thread-4,1,main]: 3
Thread[pool-1-thread-3,1,main]: 3
Thread[pool-1-thread-5,1,main]: 3
Thread[pool-1-thread-2,1,main]: 2
Thread[pool-1-thread-1,1,main]: 2
Thread[pool-1-thread-3,1,main]: 2
Thread[pool-1-thread-4,1,main]: 2
Thread[pool-1-thread-5,1,main]: 2
Thread[pool-1-thread-3,1,main]: 1
Thread[pool-1-thread-1,1,main]: 1
Thread[pool-1-thread-4,1,main]: 1
Thread[pool-1-thread-2,1,main]: 1
Thread[pool-1-thread-5,1,main]: 1
*/

toString()方法被覆盖，以便使用Thread.toString()方法来打印现成的名称，优先级及所属的“线程组”。可以看奥，最后一个线程的优先度最高，其余所有线程的优先级被设为最低。注意，优先级实在run()的开头部分设定的，在构造器中设置它们不会有任何好处，因为Executor此刻还没有开始执行任务。
在run()里，执行了100000次开销相当大的浮点运算，包括double类型的加法与除法。变量d是volatile的，以努力确保不进行任何编译器优化。如果没有加入这些运算的话，就看不到设置优先级的效果。有了这些运算，就能观察到优先级为MAX_PRIORITY的线程被线程调度器优先选择。尽管向控制台打印也是开销较大的操作，但向控制台打印不能被中断，而数学运算是可以中断的。这里运算时间足够的长，因此线程调度机制才来得及接入，交换任务并关注优先级，是的最高优先级线程被优先选择。

尽管jdk有10个优先级，但它与很多操作系统都不能映射得很好。唯一可移植的方法是当调整优先级的时候，只使用MAX_PRIORITY，NORM_PRIORITY和MIN_PRIORITY三种级别。

让步

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

但是对于任何重要的或在调整应用时，都不能依赖于yield()。实际上，yield()经常被误用。

后台线程

所谓后台daemon线程，是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。反过来说，只要有任何非后台线程还在运行，程序就不会终止。比如，执行main()的就是一个非后台线程。

import java.util.concurrent.TimeUnit;

public class SimpleDaemons implements Runnable{
	public void run(){
		try {
			while(true){
				TimeUnit.MILLISECONDS.sleep(100);
				System.out.println(Thread.currentThread()+" "+this);
			}
		} catch (InterruptedException e) {
			System.out.println("sleep() interrupted");
		}
	}
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++){
			Thread daemon=new Thread(new SimpleDaemons());
			daemon.setDaemon(true);
			daemon.start();
		}
		System.out.println("All daemons started");
		TimeUnit.MILLISECONDS.sleep(175);
	}
}
/*
All daemons started
Thread[Thread-2,5,main] SimpleDaemons@4f8ef65f
Thread[Thread-1,5,main] SimpleDaemons@77cd7513
Thread[Thread-9,5,main] SimpleDaemons@66ff652b
Thread[Thread-6,5,main] SimpleDaemons@59cda0d
Thread[Thread-5,5,main] SimpleDaemons@4a96a9c7
Thread[Thread-3,5,main] SimpleDaemons@76f0470e
Thread[Thread-8,5,main] SimpleDaemons@4f0e0bdb
Thread[Thread-4,5,main] SimpleDaemons@6b8d721c
Thread[Thread-0,5,main] SimpleDaemons@4bf9446
Thread[Thread-7,5,main] SimpleDaemons@1216b8f7
*/

必须在线程启动之前调用setDaemon()方法，才能把它设置为后台线程。

一旦main()完成其工作，就没什么能阻止程序终止了，因为除了后台线程之外已经灭有线程在运行了。main()线程被设定为短暂睡眠，所以可以观察到所有哦后台线程启动后的结果。不这样的话，你就只能看见一些后台线程创建时得到的结果。

SimpleDaemons.java创建了显式的线程，以便可以设置他们的后台标志。

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

参考书籍：《Thinking in Java》——Bruce Eckel