java并发基础

一、创建线程

　　1.使用Executor:java.util.concurrent包中的执行器（Execute)为你管理Thread对象，从而简化并发编程。

package thread;

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

public class LiftOff implements Runnable{
    public int countDown=10;//倒计时十个数
    public static int taskNumber=0;//静态的，多个LiftOff对象共享这一个变量
    public final int id=taskNumber++;//id是唯一的
    public void status(){
        System.out.println(id+"的倒计时是："+countDown);
    }
    @Override
    public void run() {
        while (countDown-->0){
            status();
            Thread.yield();
        }
    }

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

 　　　　　　exe.shutdown();

} }

其中，shutdown方法的调用，是防止新任务被提交给这个Executor,当前线程（这里指main线程），将继续运行在shutdown被调用之前提交的任务，这个程序将在Executor中的所有任务完成之后尽快退出。

　　　　1.2.FixedThreadPool（5）

　　　　1.3SingleThreadExecutor

　　　2.从任务中产生返回值

package thread;

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

public class TaskWithResult implements Callable<String> {
    private int id;
    public TaskWithResult(int id){
        this.id=id;
    }
    @Override
    public String call() throws Exception {
            return "Result id is:"+id;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        ArrayList<Future<String>> result = new ArrayList<Future<String>>();
        for(int i=0;i<5;i++){
            result.add(executorService.submit(new TaskWithResult(i)));
        }
        for (Future<String> i:result
             ) {
            try {
                System.out.println(i.get());
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                executorService.shutdown();
            }
        }
    }
}

submit方法会产生Future对象，它用Callable返回结果的特点类型进行了参数化，你可以用isDone方法查询Future是否已经完成。当任务完成时，它有一个结果，你可以调用get方法获取结果，get将被阻塞，直至数据准备就绪。

　　3。sleep()

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

猜你喜欢