美文网首页
Java线程池

Java线程池

作者: yongguang423 | 来源:发表于2018-06-17 09:48 被阅读9次

Executor

线程池顶级接口。定义方法,void execute(Runnable)。方法是用于处理任务的一个服务方法。调用者提供Runnable接口的实现,线程池通过线程执行这个Runnable。服务方法无返回值的。是Runnable接口中的run方法无返回值。
常用方法 - void execute(Runnable)
作用是: 启动线程任务的。

ExecutorService

Executor接口的子接口。提供了一个新的服务方法,submit。有返回值(Future类型)。submit方法提供了overload方法。其中有参数类型为Runnable的,不需要提供返回值的;有参数类型为Callable,可以提供线程执行后的返回值。
Future,是submit方法的返回值。代表未来,也就是线程执行结束后的一种结果。如返回值。
常见方法 - void execute(Runnable), Future submit(Callable), Future submit(Runnable)
线程池状态: Running, ShuttingDown, Termitnaed
Running - 线程池正在执行中。活动状态。
ShuttingDown - 线程池正在关闭过程中。优雅关闭。一旦进入这个状态,线程池不再接收新的任务,处理所有已接收的任务,处理完毕后,关闭线程池。
Terminated - 线程池已经关闭。

Future

未来结果,代表线程任务执行结束后的结果。获取线程执行结果的方式是通过get方法
获取的。get无参,阻塞等待线程执行结束,并得到结果。get有参,阻塞固定时长,等待线程执行结束后的结果,如果在阻塞时长范围内,线程未执行结束,抛出异常。
常用方法: T get() T get(long, TimeUnit)

/**
 * 线程池
 * 固定容量线程池
 */
package concurrent.t08;

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;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class Test_03_Future {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        /*FutureTask<String> task = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "first future task";
            }
        });
        
        new Thread(task).start();
        
        System.out.println(task.get());*/
        
        ExecutorService service = Executors.newFixedThreadPool(1);
        
        Future<String> future = service.submit(new Callable<String>() {
            @Override
            public String call() {
                try {
                    TimeUnit.MILLISECONDS.sleep(50000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("aaa");
                return Thread.currentThread().getName() + " - test executor";
            }
        });
        System.out.println(future);
        System.out.println(future.isDone()); // 查看线程是否结束, 任务是否完成。 call方法是否执行结束
        
        System.out.println(future.get()); // 获取call方法的返回值。
        System.out.println(future.isDone());
    }

}

Callable

可执行接口。 类似Runnable接口。也是可以启动一个线程的接口。其中定义的方法是call。call方法的作用和Runnable中的run方法完全一致。call方法有返回值。
接口方法 : Object call();相当于Runnable接口中的run方法。区别为此方法有返回值。不能抛出已检查异常。
和Runnable接口的选择 - 需要返回值或需要抛出异常时,使用Callable,其他情况可任意选择。

例:

/**
 * 线程池
 * 固定容量线程池, 简单应用
 */
package concurrent.t08;

import java.util.ArrayList;
import java.util.List;
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;

public class Test_04_ParallelComputingWithFixedThreadPool {
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        computing(1, 2000000);
        long end = System.currentTimeMillis();
        System.out.println("computing times : " + (end - start));
        
        ExecutorService service = Executors.newFixedThreadPool(5);
        
        ComputingTask t1 = new ComputingTask(1, 60000);
        ComputingTask t2 = new ComputingTask(60001, 110000);
        ComputingTask t3 = new ComputingTask(110001, 150000);
        ComputingTask t4 = new ComputingTask(150001, 180000);
        ComputingTask t5 = new ComputingTask(180001, 200000);
        
        Future<List<Integer>> f1 = service.submit(t1);
        Future<List<Integer>> f2 = service.submit(t2);
        Future<List<Integer>> f3 = service.submit(t3);
        Future<List<Integer>> f4 = service.submit(t4);
        Future<List<Integer>> f5 = service.submit(t5);
        
        start = System.currentTimeMillis();
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        f5.get();
        end = System.currentTimeMillis();
        System.out.println("parallel computing times : " + (end - start));
        
    }
    
    static class ComputingTask implements Callable<List<Integer>>{
        int start, end;
        public ComputingTask(int start, int end){
            this.start = start;
            this.end = end;
        }
        public List<Integer> call() throws Exception{
            System.out.println(Thread.currentThread().getName()+"开始计算");
            List<Integer> results = new ArrayList<>();
            boolean isPrime = true;
            for(int i = start; i <= end; i++){
                for(int j = 1; j < Math.sqrt(i); j++){
                    if(i % j == 0){
                        isPrime = false;
                        break;
                    }
                }
                if(isPrime){
                    results.add(i);
                }
                isPrime = true;
            }
            
            return results;
        }
    }
    
    private static List<Integer> computing(Integer start, Integer end){
        List<Integer> results = new ArrayList<>();
        boolean isPrime = true;
        for(int i = start; i <= end; i++){
            for(int j = 1; j < Math.sqrt(i); j++){
                if(i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime){
                results.add(i);
            }
            isPrime = true;
        }
        
        return results;
    }

}

关于Callable和Feature不错的文章
https://blog.csdn.net/ghsau/article/details/7451464

Executors

工具类型。为Executor线程池提供工具方法。可以快速的提供若干种线程池。如:固定容量的,无限容量的,容量为1等各种线程池。
线程池是一个进程级的重量级资源。默认的生命周期和JVM一致。当开启线程池后,直到JVM关闭为止,是线程池的默认生命周期。如果手工调用shutdown方法,那么线程池执行所有的任务后,自动关闭。
开始 - 创建线程池。
结束 - JVM关闭或调用shutdown并处理完所有的任务。
类似Arrays,Collections等工具类型的功用。

FixedThreadPool

容量固定的线程池。活动状态和线程池容量是有上限的线程池。所有的线程池中,都有一个任务队列。使用的是BlockingQueue<Runnable>作为任务的载体。当任务数量大于线程池容量的时候,没有运行的任务保存在任务队列中,当线程有空闲的,自动从队列中取出任务执行。
使用场景: 大多数情况下,使用的线程池,首选推荐FixedThreadPool。OS系统和硬件是有线程支持上限。不能随意的无限制提供线程池。
线程池默认的容量上限是Integer.MAX_VALUE。
常见的线程池容量: PC - 200。 服务器 - 1000~10000
queued tasks - 任务队列
completed tasks - 结束任务队列

/**
 * 线程池
 * 固定容量线程池
 * FixedThreadPool - 固定容量线程池。创建线程池的时候,容量固定。
 *  构造的时候,提供线程池最大容量
 * new xxxxx -> 
 * ExecutorService - 线程池服务类型。所有的线程池类型都实现这个接口。
 *  实现这个接口,代表可以提供线程池能力。
 *  shutdown - 优雅关闭。 不是强行关闭线程池,回收线程池中的资源。而是不再处理新的任务,将已接收的任务处理完毕后
 *      再关闭。
 * Executors - Executor的工具类。类似Collection和Collections的关系。
 *  可以更简单的创建若干种线程池。
 */
package concurrent.t08;

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

public class Test_02_FixedThreadPool {
    
    public static void main(String[] args) {
        ExecutorService service = 
                Executors.newFixedThreadPool(5);
        for(int i = 0; i < 6; i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.MILLISECONDS.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " - test executor");
                }
            });
        }
        
        System.out.println(service);
        
        service.shutdown();
        // 是否已经结束, 相当于回收了资源。
        System.out.println(service.isTerminated());
        // 是否已经关闭, 是否调用过shutdown方法
        System.out.println(service.isShutdown());
        System.out.println(service);
        
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // service.shutdown();
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);
    }

}

CachedThreadPool

缓存的线程池。容量不限(Integer.MAX_VALUE)。自动扩容。容量管理策略:如果线程池中的线程数量不满足任务执行,创建新的线程。每次有新任务无法即时处理的时候,都会创建新的线程。当线程池中的线程空闲时长达到一定的临界值(默认60秒),自动释放线程。
默认线程空闲60秒,自动销毁。
应用场景: 内部应用或测试应用。 内部应用,有条件的内部数据瞬间处理时应用,如:
电信平台夜间执行数据整理(有把握在短时间内处理完所有工作,且对硬件和软件有足够的信心)。 测试应用,在测试的时候,尝试得到硬件或软件的最高负载量,用于提供FixedThreadPool容量的指导。

ScheduledThreadPool

计划任务线程池。可以根据计划自动执行任务的线程池。
scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
runnable - 要执行的任务。
start_limit - 第一次任务执行的间隔。
limit - 多次任务执行的间隔。
timeunit - 多次任务执行间隔的时间单位。
使用场景: 计划任务时选用(DelaydQueue),如:电信行业中的数据整理,没分钟整理,没消失整理,每天整理等。

SingleThreadExceutor

单一容量的线程池。
使用场景: 保证任务顺序时使用。如: 游戏大厅中的公共频道聊天。秒杀。

ForkJoinPool

分支合并线程池(mapduce类似的设计思想)。适合用于处理复杂任务。
初始化线程容量与CPU核心数相关。
线程池中运行的内容必须是ForkJoinTask的子类型(RecursiveTask,RecursiveAction)。
ForkJoinPool - 分支合并线程池。 可以递归完成复杂任务。要求可分支合并的任务必须是ForkJoinTask类型的子类型。其中提供了分支和合并的能力。ForkJoinTask类型提供了两个抽象子类型,RecursiveTask有返回结果的分支合并任务,RecursiveAction无返回结果的分支合并任务。(Callable/Runnable)compute方法:就是任务的执行逻辑。
ForkJoinPool没有所谓的容量。默认都是1个线程。根据任务自动的分支新的子线程。当子线程任务结束后,自动合并。所谓自动是根据fork和join两个方法实现的。
应用: 主要是做科学计算或天文计算的。数据分析的。

/**
 * 线程池
 * 分支合并线程池。
 */
package concurrent.t08;

import java.io.IOException;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Test_08_ForkJoinPool {
    
    final static int[] numbers = new int[1000000];
    final static int MAX_SIZE = 50000;
    final static Random r = new Random();
    
    
    static{
        for(int i = 0; i < numbers.length; i++){
            numbers[i] = r.nextInt(1000);
        }
    }
    
    static class AddTask extends RecursiveTask<Long>{ // RecursiveAction
        int begin, end;
        public AddTask(int begin, int end){
            this.begin = begin;
            this.end = end;
        }
        
        // 
        protected Long compute(){
            if((end - begin) < MAX_SIZE){
                long sum = 0L;
                for(int i = begin; i < end; i++){
                    sum += numbers[i];
                }
                // System.out.println("form " + begin + " to " + end + " sum is : " + sum);
                return sum;
            }else{
                int middle = begin + (end - begin)/2;
                AddTask task1 = new AddTask(begin, middle);
                AddTask task2 = new AddTask(middle, end);
                task1.fork();// 就是用于开启新的任务的。 就是分支工作的。 就是开启一个新的线程任务。
                task2.fork();
                // join - 合并。将任务的结果获取。 这是一个阻塞方法。一定会得到结果数据。
                return task1.join() + task2.join();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException, ExecutionException, IOException {
        long result = 0L;
        for(int i = 0; i < numbers.length; i++){
            result += numbers[i];
        }
        System.out.println(result);
        
        ForkJoinPool pool = new ForkJoinPool();
        AddTask task = new AddTask(0, numbers.length);
        
        Future<Long> future = pool.submit(task);
        System.out.println(future.get());
        
    }

}

WorkStealingPool

JDK1.8新增的线程池。工作窃取线程池。当线程池中有空闲连接时,自动到等待队列中窃取未完成任务,自动执行。
初始化线程容量与CPU核心数相关。此线程池中维护的是精灵线程。
ExecutorService.newWorkStealingPool();

ThreadPoolExecutor

线程池底层实现。除ForkJoinPool外,其他常用线程池底层都是使用ThreadPoolExecutor
实现的。
public ThreadPoolExecutor
(int corePoolSize, // 核心容量,创建线程池的时候,默认有多少线程。也是线程池保持的最少线程数
int maximumPoolSize, // 最大容量,线程池最多有多少线程
long keepAliveTime, // 生命周期,0为永久。当线程空闲多久后,自动回收。
TimeUnit unit, // 生命周期单位,为生命周期提供单位,如:秒,毫秒
BlockingQueue<Runnable> workQueue // 任务队列,阻塞队列。注意,泛型必须是Runnable
);
使用场景: 默认提供的线程池不满足条件时使用。如:初始线程数据4,最大线程数200,线程空闲周期30秒。

相关文章

网友评论

      本文标题:Java线程池

      本文链接:https://www.haomeiwen.com/subject/rzoieftx.html