并发1

实现并发最直接的方式是在操作系统级别使用进程，进程是运行在它自己的地址空间内的自包容的程序。多任务操作系统可以通过周期性地将CPU从一个进程切换到另一个进程，来实现同时运行多个进程。

并发提供了一个重要的组织结构上的好处，可以使程序设计极大地简化。

下面的LiftOff任务将显示发射之前的倒计时：

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();
}
}
public static void main(String[] args) {
LiftOff lo=new LiftOff();
lo.run();
}
}
不同任务的执行在线程被换进换出时混在了一起，这种交换是由线程调度器自动控制的。

如：

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");
}
}

Executor用来管理Thread对象，从而简化了并发编程。Executor在客户端和任务执行之间提供了一个间接层，与客户端直接执行任务不同，这个中介对象将执行任务。Executor可以用来管理异步任务的执行，而无须显式地管理线程的生命周期。

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

public class CachedThreadPool {
public static void main(String[] args) {
ExecutorService exec=Executors.newCachedThreadPool();
for(int i=0;i<5;i++)
exec.execute(new LiftOff());
exec.shutdown();
}
}

Runnable是执行工作的独立任务，但是它不返回任何值。如果希望任务在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable接口.

import java.util.concurrent.Callable;

public class TaskWithResult implements Callable<String>{
private int id;
public TaskWithResult(int id){
this.id=id;
}
public String call(){
return "result of TaskWithResult"+id;
}
}

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

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<5;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();
}
}
}

影响任务行为的一种简单方法是调用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.println(status());
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();
}
}
附加：对sleep()的调用可以抛出InterruptedException异常，上述例子中，其早run()中被捕获，因为异常不能跨线程传播回main()，所以必须在本地处理在任务内部产生的异常。

上述任务是完美分布的，0到4，再回头0到4。这是很有意义的，在每个打印语句之后，每个任务都将要睡眠，这使得线程调度器可以切换到另一个线程，进而驱动另一个任务。

注意！：顺序行为依赖于底层的线程机制，这种机制在不同的操作系统之间是有差异的，因此，不能依赖于sleep()！ 而必须控制任务执行的顺序。

---恢复内容结束---