并发编程实战-任务执行

最新推荐文章于 2024-08-25 15:02:06 发布

锦衣素颜

最新推荐文章于 2024-08-25 15:02:06 发布

阅读量91

点赞数

分类专栏：并发编程实战文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/qq_33924360/article/details/128779462

版权

并发编程实战专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

1.在线程中执行任务
2.Executor框架
3.找出可利用的并行性

本章主要介绍了如何识别可并行执行的任务,以及如何在执行框架中执行它们.

1.在线程中执行任务

正常负载下,服务器应该同时表现良好的吞吐量和快速的响应性.
负荷过载时,应用程序的性能应该是逐渐降低,而不是直接失败.

要实现上述目标,应该选择清晰的任务边界和明确的任务执行策略

1.1 串行地执行任务

最简单地策略就是在单个线程中串行地执行各项任务.

public class SingleThreadWebServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(80);
        while (true){
            Socket accept = serverSocket.accept();
            handleRequest(accept);
        }
    }
    private static void handleRequest(Socket accept) {
        //do something
    }
}

上面代码,单个线程接收请求后处理相关请求,当服务器正在处理请求时,新到来地连接必须等待直到请求处理完成.
串行机制通常都无法提供高吞吐率或快速响应性.

1.2 显示地为任务创建线程

为每个请求创建一个新地线程来提供服务,从而实现更高地响应性

public class ThreadPerTaskWebServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(80);
        while (true){
            final Socket accept = serverSocket.accept();
            Runnable task = () -> handleRequest(accept);
            new Thread(task).start();
        }
    }
    private static void handleRequest(Socket accept) {
        //do something
    }
}

对于每个连接,主线程都将创建一个新线程来处理请求,而不是在主循环中进行处理.由此得出3个结论:

任务处理过程从主线程中分离出来,使得主循环能够快速地重新等待下一个到来地连接.提高响应性.
任务可以并行处理,从而能同时服务多个请求.如果有多个处理器,或者任务被阻塞,将提高吞吐量.
任务处理代码必须是线程安全地.

1.3无限制创建线程地不足

当需要创建大量线程时:

线程声明周期开销非常高.如果请求地到达率非常高且请求地处理过程是轻量级的,那么为每个请求创建一个新线程将消耗大量的计算资源.
资源消耗.活跃的线程会消耗系统资源,尤其是内存.,如果线程等待或闲置,将占用大量内存,给垃圾回收器带来压力,而且大量线程在竞争CPU资源时,还将产生其它的性能开销.
稳定性.在可创建线程的数量上存在一个限制.影响因素包括JVM启动参数,Thread构造函数中请求的栈大小,以及底层操作系统对线程的限制等.如果破坏了这些限制,很可能抛出OurOfMemoryError异常

2.Executor框架

Executor基于生产者-消费者模式.

2.1 示例

public class ThreadExecutionWebServer {
    private static final int NTHREADS = 100;
    private static final Executor exec = Executors.newFixedThreadPool(NTHREADS);
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(80);
        while (true){
            final Socket accept = serverSocket.accept();
            Runnable task = () -> handleRequest(accept);
            exec.execute(task);
        }
    }
    private static void handleRequest(Socket accept) {
        //do something
    }
}

2.2 执行策略

在执行策略中定义了任务执行的"what,where,when,hao"等方面,包括:

在什么(what)线程中执行任务?
任务按照什么(what)顺序执行(FIFO,LIFO,优先级)?
有多少个(Hao Many)任务能够并发执行?
在队列中有多少个(Hao Many)任务在等待执行?
如果系统过载需要拒绝一个任务,应该选择哪一个(Which)任务?另外,如何通知应用程序有任务被拒绝?
在执行一个任务之前或之后,应该进行哪些(What)动作?

每当看到下面这种形式的代码时:
new Thread(runnable).start()
并且你希望获得一种更灵活的执行策略时,请考虑使用Executor来代替Thread

2.3 线程池

线程池与工作队列密切相关
在线程池中执行任务比为每个任务创建线程更有优势.
Executors中几种线程池:

newFixedThreadPool:固定长度的线程池
newCachedThreadPool:可缓存的线程池,如果线程池的当前规模超过了处理需求时,那么将回收空闲的线程,而当需求增加时,则可以添加新的线程,线程池规模不受限制.
newSingleThreadExecurot:单线程线程池,如果执行线程异常,则会创建另一个线程来代替.保证任务在队列中的顺序来串行执行(FIFO,LIFO,优先级)
newScheduledThreadPool:创建了一个固定长度的线程池,而且以延迟或定时的方式来执行任务,类似于Timer

2.4 Executor的生命周期

JVM只有在所有(非守护)线程终止后才会退出,因此如果无法正确的关闭Executor,那么JVM将无法结束.
为了结局执行服务的生命周期问题,Executor拓展了ExecutorService接口,添加了一些用于生命周期管理的方法.

public interface ExecutorService extends Executor {
    //不再接收新任务,平缓的关闭,同时等待那些已经提交的任务执行完成
    void shutdown();
    //取消所有运行中的任务,并且不再启动队列中尚未开始执行的任务.
    List<Runnable> shutdownNow();
    boolean isShutdown();
    //轮询是否已经终止
    boolean isTerminated();
    //等待ExecutorService到达终止状态,通常调用后立刻调用shutdown()
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
	//...其它用于任务提交的便利方法
}

生命周期状态有3种:运行,关闭和已终止.

2.5 延迟任务与周期任务

Timer类负责管理延迟任务以及周期任务,而Timer存在一些缺陷(每次只会创建一个线程,对系统时间敏感),通常使用ScheduledThreadPoolExecutor来代替它.
如果要构建自己的调度任务,可以使用DelayQueue,它管理着一组Delayed对象.每个对象都有一个相应的延迟时间:在DelayQueue中,只有某个元素逾期后才能从DelayQueue中执行take操作.从DelayQueue中返回的对象将根据它们的延迟时间进行排序.

3.找出可利用的并行性

本节将开发不同版本的组件,并且每个版本都实现了不同程度的并发性.
示例组件实现浏览器程序中的页面渲染功能

3.1 示例: 串行的页面渲染器

class SingleThreadRenderer {
    void renderPage(CharSequence source) {
    	//先处理文本
        renderText(source);
        ArrayList<ImageData> imageData = new ArrayList<>();
        //再下载图片
        for (ImageData imageInfo : imageData) {
            imageData.add(imageInfo.downloadImage());
        }
        for (ImageData data : imageData) {
            renderImage(data);
        }
    }
}

串行执行时间总会很长,通过将问题分解为多个独立的任务并发执行,能够获得更高的CPU利用率和响应灵敏度

3.2 携带结果的任务Callable与Future

Callable可返回值,并可抛出一个异常
Executor执行的任务有4个生命周期阶段:创建,提交,开始,完成.
在Executor框架中,已提交但尚未开始的任务可以取消,但已经开始执行的任务,只有响应中断时才能取消.
Future表示一个任务的生命周期,并提供了相应的方法来判断是否已经完成或取消

public class FutureRenderer {
    private final ExecutorService executor = Executors.newFixedThreadPool(100);
    void renderPage(CharSequence source) {
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        Callable<List<ImageData>> task = () -> {
            ArrayList<ImageData> imageData = new ArrayList<>();
            for (ImageInfo imageInfo : imageInfos) {
                imageData.add(imageInfo.downloadImage());
            }
            return imageData;
        };
        Future<List<ImageData>> future = executor.submit(task);
        //渲染文本,和下载图片任务同步执行
        renderText(source);
        try {
        	//get()方法会等待线程执行完成后获取数据
            List<ImageData> imageData = future.get();
            for (ImageData data : imageData) {
                renderImage(data);
            }
        } catch (InterruptedException e) {
            //重新设置线程中断状态
            Thread.currentThread().interrupt();
            future.cancel(true);
        } catch (ExecutionException e) {
            System.out.println(e.getCause());
            e.printStackTrace();
        }
    }
}

3.3 在异构任务并行化存在的局限

通过对异构任务并行化来获得重大的性能提升是很困难的
任务的大小可能不一样,线程A和线程B都分配了任务,但是A的执行效率是B的10倍
在多个线程之间分解任务也需要性能开销
上面例子中,如果渲染文本的速度远大于下载图片的速度,那么异步和串行就没有区别,但代码复杂度增加了

只有当大量相互独立且同构的任务可以并发进行处理时,才能体现多线程同步执行带来的性能提升

3.4 CompletionService:Executor 与 BlockingQueue

CompletionService将Executor和BlockingQueue的功能融合到了一起
提供了类似于队列操作的take和poll等方法来获得已完成的结果

3.5 示例:CompletionService 实现

public class Renderer {
    private final ExecutorService executor;
    public Renderer(ExecutorService executor) {
        this.executor = executor;
    }
    void renderPage(CharSequence source) {
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        ExecutorCompletionService<ImageData> completionService = new ExecutorCompletionService<ImageData>(executor);
        //为每个图片下载创建一个独立的线程
        for (final ImageInfo imageInfo : imageInfos) {
            completionService.submit(() -> imageInfo.downloadImage());
        }
        renderText(source);
        try {
            for (int t = 0, n = imageInfos.size(); t < n; t++) {
                Future<ImageData> f = completionService.take();
                ImageData imageData = f.get();
                renderImage(imageData);
            }
        } catch (InterruptedException e) {
            //重新设置线程中断状态
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            System.out.println(e.getCause());
            e.printStackTrace();
        }
    }
}

3.6 为任务设置时限

如果某任务在指定时间无法完成,就放弃这个任务.
Future.get如果结果可用,立即返回,如果超时,抛出TimeoutException异常

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
	//Future.get()方法可设置过期时间和时间单位,过期则抛出异常,捕获异常后调用cancle方法取消任务
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}