Java多线程 之 Callable sleep yield 优先级（三）

1.Callable

通过Runnable接口定义的任务其run方法没有返回值。要想获得返回值，需要通过Callable接口来定义任务，其call方法可以有返回值。而且，Callable任务只能通过 ExecutorService.submit方法来调用。submit方法会返回Future类型的对象，可以通过isDone方法来检查任务是否完成，通过get方法来获取任务的返回值。当然也可以不调用isDone方法而直接调用get方法，这时get方法将阻塞直到任务完成得到返回值。

请看下面的实例：

package org.fan.learn.thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
/**
* Created by thinkpad on 2016/6/2.
*/
class TaskWithResult implements Callable {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
public String call() throws Exception {
return "result of Thread:#" + id ;
}
}
public class CallableDemo {
public static void main(String[] args) {
List<Future<String>> list = new ArrayList<Future<String>>();
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
list.add(executorService.submit(new TaskWithResult(i)));
}
for (Future<String> future : list) {
try {
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
System.out.println("main exit");
}
}

执行结果如下所示：

result of Thread:#0

result of Thread:#1

result of Thread:#2

result of Thread:#3

result of Thread:#4

main exit

2.sleep

在java 1.5之后，JDK提供了新的sleep作为TimeUnit的一部分。如下所示：

TimeUnit.MILLISECONDS.sleep(1000);表示休眠1000ms即1s。

Thread.sleep(1000); Thread.sleep的单位也是ms。

但是使用TimeUnit中的sleep可以很方便的看到休眠的时间单位。

3.yield

yield表示线程主动让出CPU让其他线程来执行。但是，这并不能保证将被采纳，也就是说其他线程不一定就会执行，也有可能还是这个线程执行。而且，调用yield也是在建议具有相同优先级的其他线程执行。

4.优先级

可以向调度器传递线程的优先级来向调度器说明线程的重要性。调度器倾向于让优先级高的线程来执行。当然，低优先级的线程也有机会来执行但是其执行频率稍微低了些而已。

可以通过Thread.currentThread()方法来获取当前线程的引用。调用System.out.println(Thread.currentThread)可以打印出当前线程的名字，优先级，线程组信息。

可以通过调用Thread.currentThread().getPriority()方法得到当前线程的优先级，通过调用setPriority()方法来设置优先级。注意：setPriority最好在run方法的开头，而不是在任务的构造方法中调用，因为此时执行器还没有执行任务。

如下所示（本例子只是为了说明设置优先级的方式）：

package org.fan.learn.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by thinkpad on 2016/6/2.
*/
class PriorityTask implements Runnable {
private int priority;
public PriorityTask(int priority) {
this.priority = priority;
}
public void run() {
Thread.currentThread().setPriority(priority);
System.out.println(Thread.currentThread());
}
}
public class PriorityDemo {
public static void main(String[] args) {
ExecutorService exe = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
exe.execute(new PriorityTask(Thread.MIN_PRIORITY));
}
exe.execute(new PriorityTask(Thread.MAX_PRIORITY));
exe.shutdown();
}
}

执行结果如下所示：

Thread[pool-1-thread-3,1,main]

Thread[pool-1-thread-5,1,main]

Thread[pool-1-thread-4,1,main]

Thread[pool-1-thread-6,10,main]

Thread[pool-1-thread-1,1,main]

Thread[pool-1-thread-2,1,main]

上面的执行结果从中括号中可以看到线程的名字，优先级，线程组。

注意：

《Thinking in java》中，有这么一句话，绝大多数时间里，所有线程都应该以默认的优先级运行，试图操作线程优先级通常是一种错误。

向控制台打印是不能被中断的。

而且JDK中定义了10个优先级，但是它很难与操作系统的线程优先级有一一对应的关系，因此在设置线程优先级时，通常是设置三个常量：Thread.MIN_PRIORITY，Thread.NORM_PRIORITY，Thread.MAX_PRIORITY。