java基础 Excutor

62 阅读 0 评论 41 点赞

我是靠谱客的博主害羞老师，最近开发中收集的这篇文章主要介绍java基础 Excutor，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Excutor是java自带的一个多线程框架，使用这个框架 可以让程序员无管理线程的具体生命周期。

/**
 * 测试类，重复了一百次添加新线程
 */
public class ExcutorTest {
    public static void main(String[] args)  throws InterruptedException{
        Server  server = new Server();
        for(int i = 0; i < 100; i++){
            Task task = new Task("Task" + i);
            Thread.sleep(10);
            server.submitTask(task);
        }
        server.endServer();
    }
}

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

/**
 * 线程池类，定义了一个ThreadPoolExecutor，submitTask方法输出了在 执行一个新线程
 * 时候线程池的信息，和开启一个新线程
 */
public class Server {
    private ThreadPoolExecutor executor;

    public Server() {
        executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
    }
    public void submitTask(Task task){
        System.out.println("server : A new task has arrived");
        executor.execute(task);
        System.out.println("server : Pool size :  "+ executor.getPoolSize());
        System.out.println("server : active count" + executor.getActiveCount());
        System.out.println("server : completed tasks : " + executor.getCompletedTaskCount());
    }


    public void endServer(){
        executor.shutdown();
    }
}

/**
 * 模拟任务，实现了Runnable接口，在具体的run方法中就是随机睡眠一段时间和输出构造方法传进来的参数
 */
public class Task  implements  Runnable{
    private String name;
    public Task(String name){
        this.name = name;
    }

    @Override
    public void run(){
        try{
            Long duration = (long)(Math.random() * 1000);
            System.out.println("    name is " + name);
            Thread.sleep(duration);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

    }
}

例子2

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);
//        Future为线程的返回值，这里泛型指定为Integer
        List<Future<Integer>> resultList = new ArrayList<>();
//        SumTask方法将参数传进去之后子线程就开始执行，程序员无需具体去管理了
        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.println("main : 已经完成了多少"+executor.getCompletedTaskCount()+"个任务");
            for(int i=0;i<resultList.size();i++){
                Future<Integer> result = resultList.get(i);
                System.out.println("main task :" + 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.println("1 - 1000的总和是" + total);
    }
}

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

/**
 * 实现了Callable接口的类，可以使用call方法执行子线程，执行单个子线程的时候
 * 就是串行执行的
 */
public class SumTask  implements Callable<Integer> {
    private int startNumber;
    private int endNumber;
    public SumTask(int startNumber, int endNumber){
        this.startNumber  = startNumber;
        this.endNumber = endNumber;
    }
    @Override
    public Integer call() throws Exception{
        int sum = 0;
        for(int i = startNumber; i< endNumber; i++){
            sum += i;
        }
        Thread.sleep(new Random().nextInt(1000));
        System.out.println(Thread.currentThread().getName() + "," + sum);
        return sum;
    }
}