Java并发编程（一）

一、定义任务

      线程驱动任务，因此需要一种描述任务的方式，可以用Runnable接口来提供，必需实现Runnable接口中的run方法：

public class LiftOff implements  Runnable {
protected int countDown=10;
private static int taskCount=0;
private final int id=taskCount++;
public LiftOff() {
// TODO Auto-generated constructor stub
}
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 launch=new LiftOff();
launch.run();
}
}

    id是final类，一但被赋值就不会被改变。run方法需要一个条件来跳出循环，静态方法Thread.yield()的调用是对线程调度器的一种建议，他在声明：“我已经执行完生命周期的最重要的部分了，此刻正是切换给其他任务执行一段时间的大好时机”。

二、Thread类

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

public class BasicTreads {

public static void main(String[] args) {
/*Thread thread =new Thread(new LiftOff());
thread.start();
System.out.println("Waitting for liftOff");*/
for(int i=0;i<5;i++){
new Thread(new LiftOff()).start();
}
System.out.println("Waitting for liftOff");
}

}

Thread构造器只需要一个Runnable对象。调用Thread对象的start（）方法执行必需的初始化操作，然后调用Runnable()的Run()方法，以便在在这个新线程中启动该任务。

三、使用Executor

       CachedThreadPool将为每个任务都创建一个线程

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

public class CachedThreadPool {

public static void main(String[] args)  {
// TODO Auto-generated method stub
ExecutorService exec =Executors.newCachedThreadPool();
for(int i=0;i<5;i++){
exec.execute(new LiftOff());
}
exec.shutdown();
}
}

   有了FixedThreadPool就可以一次性预先执行代价高昂的线程分配，因此就可以限制线程的数量了。

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

public class FixedThreadPool {

public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService exec=Executors.newFixedThreadPool(5);
for(int i=0;i<5;i++){
exec.execute(new LiftOff());
}
exec.shutdown();
}
}

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

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

public class SingleThreadPool {

public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService exec=Executors.newSingleThreadExecutor();
for(int i=0;i<5;i++){
exec.execute(new LiftOff());
}
exec.shutdown();
}

}

四、从任务中产生返回值

   Runnable是执行工作的独立任务，但是他不返回任何值，要想在任务完成时返回一个值，那么久可以实现Callable接口而不是Runnable接口。

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;
}
@Override
public String call() throws Exception {
return "result of TaskWithResult "+id;
}
}
public class CallableDemo {

public static void main(String[] args) {
ExecutorService exec =Executors.newCachedThreadPool();
ArrayList<Future<String>> result=new ArrayList<>();
for (int i = 0; i < 10; i++) {
result.add(exec.submit(new TaskWithResult(i)));
}
for(Future<String> fs: result){
try {
System.out.println(fs.get());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
System.out.println(e);
return;
} catch (ExecutionException e) {
// TODO Auto-generated catch block
System.out.println(e);
}finally {
exec.shutdown();
}
}
}
}