java并发框架--Executor

Executor简介

主要类

例子1

package exexutorTest;


/**
 * 测试类
 */
public class Main {
    public static void main(String[] args) {
        //创建执行服务器
        Server server = new Server();

        //创建100个任务，并发给执行器，等待完成
        for (int i = 0; i < 100; i++) {
        Task task = new Task("id "+ i);
        server.submitTask(task);//执行任务
        }
        server.endServer();
    }
}

package exexutorTest;


import java.util.Date;

/**
 * 任务类
 */
public class Task implements Runnable {

    private String id;//任务id

    public Task(String id) {
        this.id = id;
    }

    @Override
    public void run() {
        try {
            Long duration=(long)(Math.random()*1000);
            System.out.printf("%s: Task %s: Doing a task during %d seconds\n",Thread.currentThread().getName(),id,duration);
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.printf("%s: Task %s: Finished on: %s\n",Thread.currentThread().getName(),id,new Date());
    }
}

package exexutorTest;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Server {
    private ThreadPoolExecutor executor;//线程池
    public Server() {
        executor =(ThreadPoolExecutor) Executors.newCachedThreadPool();//创建默认线程池（大小可变）
       // executor = Executors.newFixedThreadPool(10);//固定大小
    }

    public void submitTask(Task task){
        System.out.println("A new Task has arrived");
        executor.execute(task);//无返回值，在将来某个时候执行给定的任务

        System.out.printf("Server: Pool Size: %d\n",executor.getPoolSize());
        System.out.printf("Server: Active Count: %d\n",executor.getActiveCount());
        System.out.printf("Server: Completed Tasks: %d\n",executor.getCompletedTaskCount());
    }
    public void endServer(){
       executor.shutdown();
    }
}

例子2

/**
 * 计算1-1000总和，分成10个任务计算
 */
package sumTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

public class SumTest {
    public static void main(String[] args) {
        // 执行线程池
        ThreadPoolExecutor executor=(ThreadPoolExecutor) Executors.newFixedThreadPool(4);

        List<Future<Integer>> resultList=new ArrayList<>();

        //统计1-1000总和，分成10个任务计算，提交任务
        for (int i=0; i<10; i++){
            SumTask calculator=new SumTask(i*100+1, (i+1)*100);
            Future<Integer> result=executor.submit(calculator);
            resultList.add(result);
        }

        do {
            System.out.printf("Main: 已经完成多少个任务: %d\n",executor.getCompletedTaskCount());
            System.out.println("结果长度"+resultList.size());
            for (int i=0; i<resultList.size(); i++) {
                Future<Integer> result=resultList.get(i);
                System.out.printf("Main: Task %d: %s\n",i,result.isDone());
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while (executor.getCompletedTaskCount()<resultList.size());//计算的线程运行完毕

        int total = 0;
        for (int i=0; i<resultList.size(); i++) {
            Future<Integer> result=resultList.get(i);
            Integer sum=null;
            try {
                sum=result.get();
                total = total + sum;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.printf("1-1000的总和:" + total);

        // 关闭线程池
        executor.shutdown();

    }
}

package sumTest;

import java.util.Random;
import java.util.concurrent.Callable;

public class SumTask implements Callable {
    private int start;
    private int end;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = start; i <= end ; i++) {
            sum += i;
        }
        Thread.sleep(new Random().nextInt(1000));
        System.out.printf("%s: %d\n",Thread.currentThread().getName(),sum);
        return sum;
    }
}