`

Java并发中的任务执行

阅读更多

     http://www.360doc.com/content/11/1126/19/1332348_167587893.shtml
这篇文章就主要讨论讨论Java并发中的任务执行,首先来看一下,任务的定义:

所谓的任务,就是抽象,离散的工作单位。你可以简单理解为代码级别的 (Runnable接口)

大多数并发应用程序都是围绕着任务进行管理的.

我们来看一小段代码:
Java代码 
package com.ivan.concurrent.charpter6; 
 
import java.net.ServerSocket; 
import java.net.Socket; 
 
/**
* 顺序化的Web Server.
* @author root
* OS:Ubuntu 9.04
* Date:2010-6-19
*/ 
public class SingleThreadWebServer { 
    public static void main(String[] args) throws Exception { 
        ServerSocket server=new ServerSocket(8080); 
        while(true){ 
            Socket socket=server.accept(); 
            handleRequest(socket); 
        } 
    } 
 
    private static void handleRequest(Socket socket) { 
        /**
         * 做相关的处理……, 比如请求运算与I/O
         *   这将会导致出现阻塞,  会延迟当前请求的处理,
         *   而且会产生非常严重的后果,比如: 假死。
         *    那样会极度考验用户的耐心,知道他忍无可忍的关闭浏览器。
         *   同时,单线程在等待IO操作时,CPU处于闲置状态,这样也降低了资源的利用率 
         *   
         *  这样的服务器,缺乏良好的吞吐量和快速的响应性。
         */ 
    } 





上面的代码是顺序地执行任务,主线程在不断接受连接与处理请求之间交替运行。
一个Web请求会做相关的处理……, 比如请求运算与I/O
这将会导致出现阻塞,  会延迟当前请求的处理,
而且会产生非常严重的后果,比如: 假死。
那样会极度考验用户的耐心,知道他忍无可忍的关闭浏览器。
同时,单线程在等待IO操作时,CPU处于闲置状态,这样也降低了资源的利用率
这样的服务器,缺乏良好的吞吐量和快速的响应性。

所以,基于上面代码的基础上,我们需要给他作些小许的改进:
Java代码 
package com.ivan.concurrent.charpter6; 
 
import java.net.ServerSocket; 
import java.net.Socket; 
 
public class ThreadPerTaskWebServer { 
    public static void main(String[] args) throws Exception { 
        ServerSocket server=new ServerSocket(80); 
        while(true){ 
            final Socket socket=server.accept(); 
            new Thread(new Runnable(){ 
                public void run() { 
                    handleRequest(socket); 
                } 
            }).start(); 
        } 
    } 
 
    protected static void handleRequest(Socket socket) { 
        /**
         *相比较而言,这样的处理方式有良好的改进:
         * 1.执行人物的负载已经脱离主线程,让主循环能更加迅速的重新开始等待下一个连接。提高了响应性
         * 2.并发处理任务,多个请求可以同时得到处理,提高了吞吐性
         * 3.任务处理代码必须要是线程安全的。防止出现并发性数据共享问题。 
         * 
         * 这个程序可能在开发阶段运行良好,一旦部署,就可能出现致命的错误,
         * 我们接着来分析:
         */ 
    } 



    相比较而言,这样的处理方式有良好的改进:
    1.执行人物的负载已经脱离主线程,让主循环能更加迅速的重新开始等待下一个连接。提高了响应性
     2.并发处理任务,多个请求可以同时得到处理,提高了吞吐性
     3.任务处理代码必须要是线程安全的。防止出现并发性数据共享问题。
   
这个程序可能在开发阶段运行良好,一旦部署,就可能出现致命的错误,
我们接着来分析:
我们看到,上面的代码中,是为每个请求的到来,创建一个新的线程来处理, 那么这样就会有以下的问题出现:

无限创建线程的缺点:
1.线程生命周期的开销
1.1.线程的创建与关闭并非是免费的,实际的开销根据不同的OS有不同的处理.但是线程的创建的确需要时间,带来处理请求的延迟.一般的Web Server的请求是很频繁的,为每个请求创建一个线程,无非要耗费大量的资源.
2.资源消耗量
2.1. 活动的线程会消耗资源,尤其是内存.如果可运行的线程数多于可用的处理器数,线程将会空闲。大量的空闲线程占用更多的内存,给垃圾回收器带来压力,而且, 线程在竞争CPU的同时,也会带来许多其他的性能开销。所以,建议在有足够多的线程让CPU忙碌时,不要再创建多余的线程.
3.应用的稳定性
3.1. 应该限制创建线程的数量,限制的数目根据不同的平台而定,同时也受到JVM的启动参数,Thread的构造函数中栈大小等因素的影响. 如果打破了这个限制,你很可能会得到一个OutOfMemoryError. 在一定范围内增加线程可以提高系统的吞吐量,但是一旦超过这个范围,再创建线程只会拖垮你的系统。甚至可能会导致应用程序的崩溃.
  
我们的解决办法:
    使用线程池,当然,你完全没有必要自己写一个线程池的实现(好吧,或许你跟我一样,也希望能从重复创造轮子中,找到自己想要了解的东西),你可以利用 Executor框架来帮你处理,java.util.concurrent提供了一个灵活的线程池实现。 在新的java类库当中,任务执行的首要抽象不是Thread,而是Executor.
    Executor仅仅是一个简单的接口,但是它很强大,包括用于异步任务的执行,支持不同类型的任务执行策略,为任务提交和任务执行之间的解藕,提供了标准的方式等等, 我们后续再重点讨论。
    Executor基于 生产者-消费者模式。提交任务的是生产者,执行任务的是消费者。 也就是说, 采用Executor框架实现 生产者-消费者模式,十分简单。
Java代码 
package com.ivan.concurrent.charpter6; 
 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.concurrent.Executor; 
import java.util.concurrent.Executors; 
 
public class TaskExecutionWebServer{ 
    private static final int NTHREADS=100; 
    //使用线程池来避免 为每个请求创建一个线程。 
    private static final Executor threadPool=Executors.newFixedThreadPool(NTHREADS); 
     
    public static void main(String[] args) throws Exception { 
        ServerSocket server=new ServerSocket(8011); 
        while(true){ 
            final Socket socket=server.accept(); 
            threadPool.execute(new Runnable(){ 
                public void run() { 
                    handleRequest(socket); 
                } 
            }); 
        } 
    } 
 
    protected static void handleRequest(Socket socket) { 
        /**
         *
         */ 
        System.out.println(Thread.currentThread().getId()); 
        try { 
            Thread.sleep(5000); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
    } 
     
     


线程池:
    线程池管理着一个工作者线程的同构池,线程池是与工作队列紧密绑定的。工作队列的作用就是持有所有等待执行的任务, 工作者队列只需要从工作队列中获取到下一个任务,执行,然后回来等待下一个线程。
    Java类库中提供了以下几种线程池:
1.newFixedThreadPool :创建定长的线程池,每当提交一个任务就创建一个线程,直到达到池的最大长度。
2.newCachedThreadPool:创建一个可缓存的线程池,如果当前线程池的长度超过了处理的需要,它可以灵活的收回空闲线程,当需求增加时,它可以灵活添加新的线程,而并不对池的长度做任何限制
3.newSingleThreadExecutor:创建单线程化的executor,它只创建唯一的工作者线程来执行任务,如果这个线程异常结束,会有另外一个线程来取代它.它会保证任务按照任务队列规定的顺序来执行。
4.NewScheduledThreadPool:创建一个定长的线程池,而且支持定时的,以及周期性的任务执行,类似Timer.

Executor的生命周期:
    它的创建已经说了,我们来看看它如何关闭, Executor 是为了执行任务而创建线程,而JVM通常会在所有非后台线程退出后才退出,如果它无法正确的关闭,则会影响到JVM的结束。
    这里需要提一下,在我们了解如何关闭Executor的一些疑惑,  由于Executor是异步执行任务,那么这些任务的状态不是立即可见的, 换句话说,在任务时间里,这些执行的任务中,有的可能已经完成,有的还可能在运行,其他的还可能在队列里面等待。 为了解决这些问题, Java引入了另外一个接口,它扩展了Executor,并增加一些生命周期的管理方法: ExecutorService.

ExecutorService表示生命周期有三种状态:  运行,关闭,终止。
    关闭和终止? 怎么看上去是一个意思, 这里我们先搁置着,留着后续来讨论。
   
ExecutorService最初创建后的初始状态就是运行状态;
    shutdown与shutdownNow方法,都是ExecutorService的关闭方法,区别在于:
    shutdown:
        会启动一个平稳的关闭过程, 停止接受新任务,同时等待已经提交的任务完成(包括尚未开始执行的任务)
    shutdownNow:
        会启动一个强制关闭的过程:尝试取消所有运行中的任务和排在队列中尚未开始的任务。

    一旦所有任务全完成后,ExecutorService会转到终止状态, awaitTermination可以用来等待ExecutorService到达终止状态,也可以轮询isTerminated判断ExecutorService是否已经终止。
Java代码 
package com.ivan.concurrent.charpter6; 
 
import java.io.IOException; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.RejectedExecutionException; 
 
/**
* 线程池的生命周期是如何管理的?
* @author root
* OS:Ubuntu 9.04
* Date:2010-6-19
*/ 
public class LifeCycleWebServer { 
    private static final int NTHREADS=100; 
    private static final ExecutorService exec=Executors.newFixedThreadPool(NTHREADS); 
     
    public void start() throws IOException{ 
        ServerSocket server=new ServerSocket(8011); 
        while(exec.isShutdown()){ 
            try { 
                final Socket socket=server.accept(); 
                exec.execute(new Runnable(){ 
                    public void run() { 
                        handleRequest(socket); 
                    } 
                }); 
            } catch (RejectedExecutionException e) { 
                if(!exec.isShutdown()){ 
                    //log.error(...) 
                } 
            } 
        } 
    } 
     
     
    protected void handleRequest(Socket socket) { 
        Request req=readRequest(socket); 
        if(isShutDown(req)){ 
            stop(); 
        }else{ 
            dispatchRequest(req); 
        } 
    } 
 
    public void stop(){ 
        exec.shutdown(); 
    } 
     
     
    //~ Mock Object And Function.. 
    private static class Request{ 
         
    } 
     
    private Request readRequest(Socket socket) { 
        // TODO Auto-generated method stub 
        return null; 
    } 
 
 
    private boolean isShutDown(Request req) { 
        // TODO Auto-generated method stub 
        return false; 
    } 
 
 
    private void dispatchRequest(Request req) { 
        // TODO Auto-generated method stub 
         
    } 
     



OK,了解了线程池的使用,这里有必要介绍介绍执行策略,
执行策略:
    简单来说,就是任务执行的”What,When,Where,How”,包括:
1.任务在什么线程中执行(what)
2.任务以什么顺序执行(fifo,lifo,优先级)?
3.可以有多少个任务并发执行?(how many)
4.可以有多少个任务进入等待执行队列
5.系统过载时,需要放弃一个任务,该挑选哪一个? 如何通知应用程序知道?


另外,java类库中还提供有一种特别的任务,----可携带结果的任务:
    Callable 和 Future
    Runnable 作为任务的基本表达形式只是个相当有限的抽象; 它的局限在于,不能返回一个值或者抛出受检查的异常。
    通常,很多任务都会引起严重的计算延迟,比如执行数据库查询,从网络下载资源,进行复杂的计算。对于这样的任务,Callable是更佳的抽象: 它在主进入点,等待返回值,并为可能抛出的异常预先作准备。
    Runnable与Callable描述的都是首相的计算型任务,这些任务通常都是有限的。,任务的所生命周期分为4个阶段: 创建、提交、开始和完成。
    Future描述了任务的生命周期,并提供了相关的方法来获取任务的结果、取消任务以及检验任务是否已经完成或者被取消。
    Future的get方法取决于任务的状态, 如果任务已经完成,get会立即返回或者抛出异常,如果任务没有完成,get会阻塞直到它的完成。
   
    创建Future的方法有很多, ExecutorService的submit会返回一个Future,你可以将一个Callable或者Runnable提交给executor,然后得到一个Future,用它来重新获得任务执行的结果,或者取消任务。
    你也可以显示的为给定的Callable和Runnable实例化一个FutureTask.
   
OK, 前面介绍了很多关于并发的理论知识,下面我们来看看,如果寻找可强化的并发性。

首先,我们从一个例子开始, 开始之前,简单介绍一下这个例子所要表达的事情:
    它的来源是浏览器程序中渲染页面的那部分功能, 首先获取HTML,并将它渲染到图像缓存里。为了简单起见,我们假设HTML只有文本标签。 OK, 开始吧。

    首先,如果按照一般的处理方式,我们会这样做:
1.遇到文本标签,将它渲染到图像缓存中
2.当遇到的是一个图片标签,我们通过网络获取它,再将它放到缓存里面。
   
    很明显,这是最简单的方式, 它很容易实现,但是,问题在于,你这样做,是在考验用户的耐心,结果就是他会对着屏幕丢一句 ****.然后毫不犹豫的关掉浏览器.

    另外一种方法:
     它先渲染文本,并为图像预留出占位符;在完成第一趟文本处理后,程序返回开始,并下载图像,将它们绘制到占位符上去。 但是这样的问题也很明显, 需要最少2次的文档处理, 其性能与效率稍有提升,但是还不足解决用户希望快速浏览页面的需求。

    为了使我们的渲染器具有更高的并发性,我们需要做的第一步就是, 将渲染过程分为两部分: 一个用来渲染文本,一个用来下载所有图像。(一个受限于CPU,另外一个受限于IO, 即使在单CPU系统上,效率的提升也很明显。)
    Callable与Future可以用来表达所有协同工作的任务之间的交互。我们来看代码:
Java代码 
package com.ivan.concurrent.charpter6; 
 
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 FutureRenderer { 
    private static final int NTHREADS=100; 
    private static final ExecutorService exec=Executors.newFixedThreadPool(NTHREADS); 
     
    void renderPage(CharSequence source){ 
        final List<ImageInfo> imageinfos=scanForImageInfo(source); 
        Callable<List<ImageData>> task= 
                new Callable<List<ImageData>>(){ 
                    public List<ImageData> call() throws Exception { 
                        List<ImageData> result=new ArrayList<ImageData>(); 
                        for(ImageInfo imageinfo:imageinfos){ 
                            result.add(imageinfo.downloadImage()); 
                        } 
                        return result; 
                    } 
             
        }; 
         
         
        Future<List<ImageData>> future=exec.submit(task); 
        //保证渲染文本与下载图像数据并发执行。 
        renderText(source); 
        try { 
            /**
             * 到达需要所有图像的时间点时,主任务会等待future.get调用的结果,
             *  幸运的话,我们请求的同时,下载已经完成,即使没有,下载也已经预先开始了。
             *  
             *  这里还有一定的局限性, 用户可能不希望等待所有图片下载完成后才可以看见,
             *   他希望下载完成一张图片后,就可以立即看到。 …… 这里还待优化。
             */ 
            List<ImageData> imageData=future.get(); 
             
            for(ImageData data:imageData){ 
                reanderImage(data); 
            } 
        } catch (InterruptedException e) { 
            Thread.currentThread().interrupt(); 
            future.cancel(true);//取消任务 
        }catch(ExecutionException e){ 
            e.printStackTrace(); 
             
        } 
    } 
 
    private void renderText(CharSequence source) { 
        // TODO Auto-generated method stub 
         
    } 
 
    private void reanderImage(ImageData data) { 
        // TODO Auto-generated method stub 
         
    } 
 
    private List<ImageInfo> scanForImageInfo(CharSequence source) { 
        // TODO Auto-generated method stub 
        return null; 
    } 


CompletionService: 当executorService遇到BlockingQueue
    CompletionService整合了Executor和BlockingQueue的功能,你可以将Callable任务提交给它去执行,然后使用类似于队列中的take和poll方法,在结果完成可用时,获得这个结果,像一个打包的Future.
  我们利用它来为我们的渲染器需要优化的地方做些处理,代码如下:
Java代码 
package com.ivan.concurrent.charpter6; 
 
import java.util.List; 
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; 
import java.util.concurrent.Future; 
 
public class FutureRenderer2 { 
    private static final int NTHREADS=100; 
    private static final ExecutorService exec=Executors.newFixedThreadPool(NTHREADS); 
     
    void renderPage(CharSequence source){ 
        final List<ImageInfo> imageinfos=scanForImageInfo(source); 
         
        CompletionService<ImageData> completionService=new ExecutorCompletionService<ImageData>(exec); 
         
        for(final ImageInfo imageinfo:imageinfos){ 
            completionService.submit(new Callable<ImageData>(){ 
                public ImageData call() throws Exception { 
                    //提高性能点一: 将顺序的下载,变成并发的下载,缩短下载时间 
                    return imageinfo.downloadImage(); 
                } 
            }); 
        } 
        renderText(source); 
        try { 
            for(int i=0;i<imageinfos.size();i++){ 
                Future<ImageData> f=completionService.take(); 
                //提高性能点二: 下载完成一张图片后,立刻渲染到页面。 
                ImageData imagedata=f.get(); 
                reanderImage(imagedata); 
            } 
        } catch (InterruptedException e) { 
            Thread.currentThread().interrupt(); 
        }catch(ExecutionException e){ 
            e.printStackTrace(); 
             
        } 
    } 
 
    private void renderText(CharSequence source) { 
        // TODO Auto-generated method stub 
         
    } 
 
    private void reanderImage(ImageData data) { 
        // TODO Auto-generated method stub 
         
    } 
 
    private List<ImageInfo> scanForImageInfo(CharSequence source) { 
        // TODO Auto-generated method stub 
        return null; 
    } 

 
本文参考于Java并发大师Brian Goetz的 《Java并发编程与实践》第6章, 文中有自己的一些理解,也可以算是读书笔记。
分享到:
评论

相关推荐

    java并发编程实战源码,java并发编程实战pdf,Java

    在Java并发编程中,主要涉及以下几个关键知识点: 1. **线程与进程**:线程是程序执行的最小单元,一个进程中可以有多个线程同时执行。理解线程的概念和生命周期对于并发编程至关重要。 2. **线程安全**:当多个...

    Java并发任务执行.pdf

    在上述的"Java并发任务执行.pdf"文档中,通过一个简单的单线程Web服务器示例来阐述了并发任务执行的重要性。 在Java中,任务通常表现为实现了`Runnable`接口的对象,它代表了一段可以被独立执行的代码逻辑。在提供...

    java并发编程2

    Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释: 1. **线程与并发** - **线程*...

    《java 并发编程实战高清PDF版》

    在Java并发编程中,多线程是核心概念之一。多线程允许程序同时执行多个任务,从而充分利用系统资源,提高程序性能。然而,多线程编程也带来了同步和竞态条件等问题,这需要开发者具备良好的线程管理和同步机制的知识...

    Java并发实战

    《Java并发实战》是深入探讨Java编程中并发处理的一本技术书籍。在现代软件开发中,多线程和并发控制是提升程序性能的关键技术,尤其是在服务器端开发中尤为重要。Java作为一门成熟的编程语言,其在并发控制方面提供...

    java并发编程内部分享PPT

    Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。这份“java并发编程内部分享PPT”显然是一个深入探讨这一主题的资料,旨在帮助开发者...

    Java 并发编程实战.pdf

    根据提供的信息,“Java 并发编程实战.pdf”这本书聚焦于Java并发编程的实践与应用,旨在帮助读者深入了解并掌握Java中的多线程技术及其在实际项目中的应用技巧。虽然部分内容未能提供具体章节或实例,但从标题及...

    Java并发编程实践高清pdf及源码

    在Java并发编程中,"并发"是指在单个程序中同时执行多个任务,这通常通过多线程实现。Java平台提供了丰富的API来支持并发,如`Thread`类、`ExecutorService`接口和`Future`接口等。这些工具允许开发者设计出能够充分...

    java并发编程与实践

    "Java并发编程与实践"文档深入剖析了这一主题,旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元(如CPU)中同时执行两个或更多任务的能力。在Java中,这主要通过线程来实现,...

    (PDF带目录)《Java 并发编程实战》,java并发实战,并发

    《Java 并发编程实战》是一本专注于Java并发编程的权威指南,对于任何希望深入了解Java多线程和并发控制机制的开发者来说,都是不可或缺的参考资料。这本书深入浅出地介绍了如何在Java环境中有效地管理和控制并发...

    JAVA并发编程艺术pdf版

    通过深入学习《JAVA并发编程艺术》,开发者能更好地理解并发编程的原理,熟练运用Java提供的并发工具和API,解决实际开发中的多线程问题,提高软件的性能和稳定性。这是一本值得每一位Java开发者研读的书。

    java并发编程书籍

    Java并发编程是软件开发中的一个关键领域,尤其是在大型企业级应用和分布式系统中。通过学习相关的书籍,开发者可以深入理解如何有效地设计和实现高效的多线程应用程序,避免并发问题,如竞态条件、死锁、活锁等。...

    java并发编程实践pdf笔记

    Java并发编程实践是Java开发中不可或缺的一个领域,它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点,旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...

    Java 并发核心编程

    Java的`java.util.concurrent.Executor`框架提供了一种灵活的方式来管理和控制线程池中的任务执行: 1. **ThreadPoolExecutor**: 提供了一个可配置的线程池实现。 2. **ScheduledExecutorService**: 支持定时任务和...

    Java并发编程实战

    第6章 任务执行 6.1 在线程中执行任务 6.1.1 串行地执行任务 6.1.2 显式地为任务创建线程 6.1.3 无限制创建线程的不足 6.2 Executor框架 6.2.1 示例:基于Executor的Web服务器 6.2.2 执行策略 6.2.3 线程池...

    java并发编程

    Java并发编程是Java开发者必须掌握的关键技能之一,它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的计算能力,提高应用程序的响应速度和整体性能。《Java编程并发实战》这本书是...

    Java并发编程常识-梁飞.rar

    Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。阿里大牛梁飞编写的《Java并发编程常识》PPT,深入浅出地讲解了这个主题,对开发者来...

    Java并发编程-3.pdf

    Java并发编程中的多线程协作机制 在 Java 并发编程中,多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中,多个线程之间如何协作、同步和通信,以达到共同完成某个任务的目的。Java 提供了多种...

    Java并发编程相关资料

    Java并发编程是Java开发中的重要领域,涉及到多线程、同步机制、线程池等多个核心概念,对于构建高效、稳定的应用至关重要。这份资料包含了关于Java并发编程的博客和网页,可以提供深入的理解和实践指导。 在Java...

Global site tag (gtag.js) - Google Analytics