Executor框架的使用简介

最新推荐文章于 2022-03-17 02:50:39 发布
最新推荐文章于 2022-03-17 02:50:39 发布
阅读量309 收藏 1
点赞数
分类专栏： java概率总结

文章转自:http://blog.csdn.net/qq_16811963/article/details/52161713

类似于我们熟悉的集合框架（由Collection和Map接口衍生出很多其他的接口和类），在JAVA多线程中，也存在一个Executor框架。等以后时间充足了，会对该框架来一波源码剖析。

简而言之，Executor框架实现了工作单元与执行单元的分离。

本文用到的程序源码请参考我的github。

一.Executor框架的两级调度模型

在HotSpot VM的线程模型中，JAVA线程被一对一映射为本地操作系统线程。JAVA线程启动时会启动一个本地操作系统线程：当该JAVA线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。

两级调度模型的示意图：

这里写图片描述

从图中可以看出，该框架用来控制应用程序的上层调度（下层调度由操作系统内核控制，不受应用程序的控制）。

二.Executor框架的结构

Executor主要由三部分组成：任务产生部分，任务处理部分，结果获取部分。（设计模式：生产者与消费者模式）

先来看个图：

这里写图片描述

1.任务的产生：Runnable接口和Callable接口

这2个对象属于任务对象。工具类Executors可以把一个Runnable对象封装为Callable对象。当我们拥有任务对象之后，就可以将其交给ExecutorService（Executor的一个实现接口）了，这样转入第二部分–任务处理部分。

2.任务的处理：Executor接口—>ExecutorService接口

任务的处理主要是将任务丢到线程池中，由线程池提供线程将任务“消费掉”。

线程池有2类：ThreadPoolExecutor和ScheduledThreadPoolExecutor。2种线程池类均可以通过工厂类Executors来创建。

⑴：ThreadPoolExecutor类

工厂类可以创建3种类型的ThreadPoolExecutor类：

①：FixedThreadPool：拥有固定数量线程的线程池，限制了线程的数目，适用于负载比较重的服务器。

②：SingleThreadPool：单个线程的线程池，适用于需要保证顺序的执行各个任务；任意时间点，不会有多个线程活动。

③：CachedThreadPool：大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器。

⑵：ScheduleThreadPoolExecutor类

工厂类可以创建2种类型的SchedulePoolExecutor类：

①：ScheduleThreadPoolExecutor：包含若干线程。

②：SingleThreadScheduleExecutor:单个线程。

3.任务结果的获取：Future接口

Future接口有个实现类FutureTask，迄今为止API中返回的都是FutureTask对象，未来的JDK实现中，可能有Future对象。

关于Executor框架的架构基本就这些，下面用几个Demo实测一下：

1.下面这个程序实现了启动一个2个线程的线程池并给该线程池扔入5个任务，结果显示了他们的执行策略：

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

/*
 * @author Vayne
 * 
 * Executors是线程池框架的一个工具类
 * 
 * 
 */
public class FixedThreadPoolDemo
{
    public static void main(String[] args)
    {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 定义一个循环，添加5个任务
        for (int i = 0; i < 5; i++)
        {
            int flag = i;
            pool.execute(new Runnable()
            {
                //任务详情：执行6次打印语句。
                @Override
                public void run()
                {
                    for(int j = 0;j<6;j++)
                    {
                        try
                        {
                            Thread.sleep(10);
                        } catch (InterruptedException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+" "+flag+" "+" `s loop : "+j);
                    }
                }
            });
        }

        pool.shutdown();

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

结果：

pool-1-thread-1 0  `s loop : 0
pool-1-thread-2 1  `s loop : 0
pool-1-thread-1 0  `s loop : 1
pool-1-thread-2 1  `s loop : 1
pool-1-thread-1 0  `s loop : 2
pool-1-thread-2 1  `s loop : 2
pool-1-thread-2 1  `s loop : 3
pool-1-thread-1 0  `s loop : 3
pool-1-thread-1 0  `s loop : 4
pool-1-thread-2 1  `s loop : 4
pool-1-thread-1 0  `s loop : 5
pool-1-thread-2 1  `s loop : 5           //这里2个线程将2个任务完成
pool-1-thread-1 3  `s loop : 0
pool-1-thread-2 2  `s loop : 0
pool-1-thread-2 2  `s loop : 1
pool-1-thread-1 3  `s loop : 1
pool-1-thread-2 2  `s loop : 2
pool-1-thread-1 3  `s loop : 2
pool-1-thread-2 2  `s loop : 3
pool-1-thread-1 3  `s loop : 3
pool-1-thread-2 2  `s loop : 4
pool-1-thread-1 3  `s loop : 4
pool-1-thread-1 3  `s loop : 5
pool-1-thread-2 2  `s loop : 5          //2个任务完成
pool-1-thread-1 4  `s loop : 0
pool-1-thread-1 4  `s loop : 1
pool-1-thread-1 4  `s loop : 2
pool-1-thread-1 4  `s loop : 3
pool-1-thread-1 4  `s loop : 4
pool-1-thread-1 4  `s loop : 5          //最后1个任务完成
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

下面我们再来看看CachedThreadPool的实测结果，由于代码区别只是构造方法的不同，这里不浪费页面贴代码了，直接贴出结果：

pool-1-thread-2 1  `s loop : 0
pool-1-thread-4 3  `s loop : 0
pool-1-thread-5 4  `s loop : 0
pool-1-thread-3 2  `s loop : 0
pool-1-thread-1 0  `s loop : 0    //一次开启了5个线程来承载5次任务
pool-1-thread-4 3  `s loop : 1
pool-1-thread-2 1  `s loop : 1
pool-1-thread-5 4  `s loop : 1
pool-1-thread-3 2  `s loop : 1
pool-1-thread-1 0  `s loop : 1
pool-1-thread-4 3  `s loop : 2
pool-1-thread-2 1  `s loop : 2
pool-1-thread-1 0  `s loop : 2
pool-1-thread-5 4  `s loop : 2
pool-1-thread-3 2  `s loop : 2
pool-1-thread-2 1  `s loop : 3
pool-1-thread-4 3  `s loop : 3
pool-1-thread-1 0  `s loop : 3
pool-1-thread-5 4  `s loop : 3
pool-1-thread-3 2  `s loop : 3
pool-1-thread-2 1  `s loop : 4
pool-1-thread-4 3  `s loop : 4
pool-1-thread-1 0  `s loop : 4
pool-1-thread-5 4  `s loop : 4
pool-1-thread-3 2  `s loop : 4
pool-1-thread-2 1  `s loop : 5
pool-1-thread-4 3  `s loop : 5
pool-1-thread-5 4  `s loop : 5
pool-1-thread-1 0  `s loop : 5
pool-1-thread-3 2  `s loop : 5
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

2.结合Future接口来做一个实测

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FutureDemo
{
    public static void main(String[] args)
    {

        ExecutorService pool = Executors.newFixedThreadPool(3);

        //CompletionService接口内部维护一个结果队列:一堆future....
        CompletionService<Integer> cs = new ExecutorCompletionService<>(pool);

        for (int i = 1; i < 11; i++)
        {
            final int flag = i * 10;
            cs.submit(new Callable<Integer>()
            {

                @Override
                public Integer call() throws Exception
                {
                    // TODO Auto-generated method stub
                    Thread.sleep(1000);
                    return flag;
                }
            });
        }

        for (int i = 0; i < 11; i++)
        {
            try
            {
                System.out.println(cs.take().get());
            } catch (InterruptedException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        pool.shutdown();

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

结果：

10
20
30
50
40
60
70
90
80
100
傲宇苍穹
关注
专栏目录
Executor框架浅析
qq_40414067的博客
07-07 157
1.回顾线程的创建 Thread a = new Thread(task); a.start(); Thread t1 = new Thread(task1); a.start(); Thread t2 = new Thread(task2); a.start(); Thread t3 = new Thread(task3); a.start(); Thread t4 = new Thread(task4); a.start(); …… 缺点： 不断地创建新的线程------影响系统性能。 服务器无
Executor框架使用详解
03-20
NULL 博文链接：https://jsx112.iteye.com/blog/865884
Executor框架的使用
Sqrt1230的博客
03-17 527
//为每一个任务创建一个新线程的缺点： //①线程的创建与销毁开销很大 //②大量的线程将占据大量的资源，比如内存空间，容易造成服务器资源耗尽而崩溃 //③可创建的线程数量受到操作系统等因素的限制，如果破坏了这些限制，可能抛出异常 //使用Executor将任务的提交与执行解耦，提高程序的并发度，由此获得并发性，并且避免了为每一个任务创建一个新线程产生的问题 class ExecutorTest{ private static final Executor executor = Executor
Executor框架
lfangmu的博客
12-18 337
1、Executor：接口，执行器，将任务的提交和执行解耦 2、ExecutorService：Executor的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法 3、AbstractExecutorService：抽象类，ExecutorService执行方法的默认实现，但未实现Executor的execute方法 4、ThreadPoolExecutor：Executor框架最核心的类，继承AbstractExecutorService，实现了Exe
Java线程Executor框架详解与使用
路漫漫，水迢迢
05-26 9683
在HotSpot VM的线程模型中，Java线程被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收，在JVM中我们可以通过-Xss设置每个线程的大小。操作系统会调度所有线程并将它们分配给可用的CPU。 在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器（Executor框架）将这些任务映射为固定
Java Executor 框架的实例详解
08-29
Executor 框架的实例详解可以帮助开发者更好地理解和使用 Executor 框架，以下是 Java Executor 框架的实例详解的相关知识点： 一、Executor 框架的介绍 Executor 框架是 Java 中一个高级的并发编程模型，提供了一...
Java基础篇：Executor框架.pdf
05-07
该文档详细记录了Executor框架结构、使用示意图、ThreadPoolExecutor使用示例、线程池原理分析、几种常见线程池（FixedThreadPool、SingleThreadExecutor、CachedThreadPool）的详解以及线程池大小确定等内容
Java并发Executor框架
12-22
1、Executor框架简介 　从JDK5开始，工作单元和执行机制隔离开来，工作单元包括Runnable和Callable，执行机制由Executor提供。 　调用关系：Java线程一对一映射到本地操作系统的系统线程，当多线程程序分解若干...
Java并发之线程池Executor框架的深入理解
08-26
Java并发之线程池Executor框架的深入理解 Java中的线程池Executor框架是Java并发编程中的一种常见机制，用于管理和执行异步任务。通过使用线程池，可以大大减少线程的创建和销毁开销，从而提高系统的性能和稳定性。...
Executor框架---简介
喜三仔的世界
10-09 209
 在Java中，使用线程来异步执行任务。Java线程的创建与销毁需要一定的开销，如果我们为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。  Java的线程既是工作单元，也是执行机制。从JDK 5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机...
第十章 Executor框架
weixin_30332241的博客
10-03 147
在Java中，使用线程来异步执行任务。Java线程的创建与销毁需要一定的开销，如果我们为每一个任务创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时，为每一个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。 Java的线程既是工作单元，也是执行机制。从JDK1.5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机...
Executors框架
菩提本无树 明镜亦非台 本来无一物 何处惹尘埃
01-17 633
通常java最简单的线程的例子是这样的： 在较小的程序中这样实践是没有问题的；但是在大规模的应用中将线程的管理和创建部分与应用部分分开则比较合理。可以提高管理效率和节省线程反复创建和销毁带来的开销。 那么封装了线程管理和创建这些功能的对象就是 java.util.concurrent.Executors ...
java Executor框架使用案例
最新发布
09-15
好的，我可以为您提供一个简单的Java Executor框架使用示例。 Java Executor框架是Java SE 5引入的一个并发执行框架，它提供了一种方便的方式来管理并发任务的执行。在这个示例中，我们将使用Executor框架来执行一个简单的计算任务。 首先，我们需要定义一个实现Callable接口的任务类，该接口可以返回一个结果，并抛出一个可能发生的异常。这是一个简单的任务类示例： ``` import java.util.concurrent.Callable; public class MyTask implements Callable<Integer> { private int number; public MyTask(int number) { this.number = number; } @Override public Integer call() throws Exception { int result = 0; for (int i = 1; i <= number; i++) { result += i; } return result; } } ``` 这个任务类会计算从1到给定数字的和，并返回结果。接下来，我们需要创建一个ExecutorService，它是一个高级线程池实现，可以管理并发执行的任务。我们可以使用Executors类中的静态工厂方法来创建ExecutorService实例： ``` import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Main { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); Future<Integer> future = executor.submit(new MyTask(10)); try { Integer result = future.get(); System.out.println(result); } catch (Exception e) { e.printStackTrace(); } executor.shutdown(); } } ``` 在这个示例中，我们创建了一个单线程的ExecutorService，然后使用submit()方法提交了一个MyTask实例。submit()方法返回一个Future对象，我们可以使用它来检查任务是否完成，并获取任务的结果。 在这个示例中，我们使用了future.get()方法来获取任务的结果。get()方法是一个阻塞方法，它会等待任务完成并返回结果，如果任务抛出了异常，它会将异常重新抛出。因此，在调用get()方法时，我们需要使用try-catch块来处理可能抛出的异常。 最后，我们需要调用ExecutorService的shutdown()方法来关闭线程池并释放资源。这个方法会等待所有任务完成并关闭线程池，所以我们应该在使用ExecutorService后立即调用它。 这就是一个简单的Java Executor框架使用示例。希望对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值