`

java多线程 -- 线程的构架(线程池)

阅读更多
    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.ScheduledExecutorService;  
    import java.util.concurrent.TimeUnit;  
      
    /** 
     * 在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的, 
     * 任务的提于交和执行是同时进行的,如果你想对任务的执行进行调度, 
     * 或是控制同时执行的线程数量就需要额外编写代码来完成。 
     * 5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行, 
     * 并且可以建立一个类似数据库连接池的线程池来执行任务。 
     * 这个架构主要有三个接口和其相应的具体类组成。 
     * 这三个接口是Executor, ExecutorService和ScheduledExecutorService。 
     * (1)Executor接口:是用来执行Runnable任务的,它只定义一个方法: 
     * execute(Runnable command):执行Ruannable类型的任务 
     * (2)ExecutorService:继承了Executor的方法,并提供了执行Callable任务和中止任务执行的服务, 
     * 其定义的方法主要有: 
     * submit(task):可用来提交Callable或Runnable任务,并返回代表此任务的Future对象  
     * invokeAll(collection of tasks):批处理任务集合,并返回一个代表这些任务的Future对象集合  
     * shutdown():在完成已提交的任务后关闭服务,不再接受新任务  
     * shutdownNow():停止所有正在执行的任务并关闭服务。  
     * isTerminated():测试是否所有任务都执行完毕了。  
     * isShutdown():测试是否该ExecutorService已被关闭 
     * (3)ScheduledExecutorService:继承ExecutorService,提供了按时间安排执行任务的功能、 
     * schedule(task, initDelay): 安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。 
     * scheduleAtFixedRate():安排所提交的Runnable任务按指定的间隔重复执行  
     * scheduleWithFixedDelay():安排所提交的Runnable任务在每次执行完后,等待delay所指定的时间后重复执行。 
     *  
     * 通过Executors类来获得各种服务对象。 
     * callable(Runnable task): 将Runnable的任务转化成Callable的任务  
     * newSingleThreadExecutor: 产生一个ExecutorService对象,这个对象只有一个线程可用来执行任务,若任务多于一个,任务将按先后顺序执行。  
     * newCachedThreadPool(): 产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,线程执行完任务后返回线程池,供执行下一次任务使用。 
     * newFixedThreadPool(int poolSize):产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,若任务数量大于poolSize,任务会被放在一个queue里顺序执行。  
     * newSingleThreadScheduledExecutor:产生一个ScheduledExecutorService对象,这个对象的线程池大小为1,若任务多于一个,任务将按先后顺序执行。  
     * newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象,这个对象的线程池大小为poolSize,若任务数量大于poolSize,任务会在一个queue里等待执行  
     */  
    public class ExecuteArch {  
          
        /** 
         * 该线程输出一行字符串 
         */  
        public static class MyThread implements Runnable {  
            public void run() {  
                System.out.println("Task repeating. " + System.currentTimeMillis());  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    System.out.println("Task interrupted. "  
                            + System.currentTimeMillis());  
                }  
            }  
        }  
      
        /** 
         * 该Callable结束另一个任务 
         */  
        public static class MyCallable implements Callable {  
            private Future future;  
      
            public MyCallable(Future future) {  
                this.future = future;  
            }  
      
            public String call() {  
                System.out.println("To cancell Task..."  
                        + +System.currentTimeMillis());  
                this.future.cancel(true);  
                return "Task cancelled!";  
            }  
        }  
      
        /** 
         * @param args 
         * @throws ExecutionException  
         * @throws InterruptedException  
         */  
        public static void main(String[] args) throws InterruptedException,  
                ExecutionException {  
            // 产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,  
            // 线程执行完任务后返回线程池,供执行下一次任务使用。  
            ExecutorService cachedService = Executors.newCachedThreadPool();  
            Future myThreadFuture = cachedService.submit(new MyThread());  
            Future myCallableFuture = cachedService.submit(new MyCallable(  
                    myThreadFuture));  
            System.out.println(myCallableFuture.get());  
            System.out.println("-----------------");  
      
            // 将Runnable任务转换成Callable任务  
            Callable myThreadCallable = Executors.callable(new MyThread());  
            Future myThreadCallableFuture = cachedService.submit(myThreadCallable);  
            // 对于Runnable任务,转换成Callable任务后,也没有返回值  
            System.out.println(myThreadCallableFuture.get());  
            cachedService.shutdownNow();  
            System.out.println("-----------------");  
      
            // 产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,  
            // 若任务数量大于poolSize,任务会被放在一个queue里顺序执行  
            ExecutorService fixedService = Executors.newFixedThreadPool(2);  
            fixedService.submit(new MyThread());  
            fixedService.submit(new MyThread());  
            // 由于线程池大小为2,所以后面的任务必须等待前面的任务执行完后才能被执行。  
            myThreadFuture = fixedService.submit(new MyThread());  
            myCallableFuture = fixedService.submit(new MyCallable(myThreadFuture));  
            System.out.println(myCallableFuture.get());  
            fixedService.shutdownNow();  
            System.out.println("-----------------");  
      
            // 产生一个ScheduledExecutorService对象,这个对象的线程池大小为poolSize,  
            // 若任务数量大于poolSize,任务会在一个queue里等待执行  
            ScheduledExecutorService fixedScheduledService = Executors  
                    .newScheduledThreadPool(2);  
            // 新建任务1  
            MyThread task1 = new MyThread();  
            // 使用任务执行服务立即执行任务1,而且此后每隔2秒执行一次任务1。  
            myThreadFuture = fixedScheduledService.scheduleAtFixedRate(task1, 0, 2,  
                    TimeUnit.SECONDS);  
            // 新建任务2  
            MyCallable task2 = new MyCallable(myThreadFuture);  
            // 使用任务执行服务等待5秒后执行任务2,执行它后会将任务1关闭。  
            myCallableFuture = fixedScheduledService.schedule(task2, 5,  
                    TimeUnit.SECONDS);  
            System.out.println(myCallableFuture.get());  
            fixedScheduledService.shutdownNow();  
        }  
    }  

 

1
1
分享到:
评论

相关推荐

    Java多线程-Socket编程

    Java 多线程-Socket 编程 Java 多线程-Socket 编程是指在 Java 语言中使用多线程技术来实现网络编程,特别是使用 Socket 编程来实现客户端和服务器端的通信。在 Java 中,多线程可以使用 Thread 类和 Runnable 接口...

    JAVA线程、线程池资料----下载不扣分,回帖加1分,欢迎下载,童叟无欺

    在多线程大师Doug Lea的贡献下,在JDK1.5中加入了许多对并发特性的支持,例如:线程池。.......................................JAVA线程、线程池资料----下载不扣分,回帖加1分,欢迎下载,童叟无欺JAVA线程、...

    ASP.Net 多线程-IIS搭建-线程池-video

    本教程围绕"ASP.Net 多线程-IIS搭建-线程池-video"的主题,深入探讨了以下几个关键知识点: 1. **委托与多线程**:在.NET框架中,委托是一种类型安全的函数指针,可以用于传递方法作为参数。在多线程环境中,委托常...

    JAVA线程高级-线程按序交替执行

    在Java编程中,多线程是并发编程的重要组成部分,它允许程序同时执行多个任务,从而提高了系统的效率和响应性。然而,在某些场景下,我们可能需要控制线程的执行顺序,确保它们按照特定的顺序交替运行,这在并发编程...

    Java多线程--等待所有子线程执行完的五种方法.docx

    在Java多线程编程中,有时我们需要确保所有子线程执行完毕后再进行后续操作,例如在并发测试、数据聚合或资源清理等场景。本篇文章将详细介绍五种在Java中等待所有子线程执行完的方法。 ### 方法一:使用`sleep`...

    Java多线程-JDK5.0新增线程创建方式

    ### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1:实现Callable接口 ##### (1)介绍 自Java 5.0起,为提高线程管理的灵活性与效率,引入了`Callable`接口,这是一种全新的创建线程的方式。与传统的`...

    Java多线程Executors批量执行数据实现限流

    Java多线程实现数据切割批量执行,实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据,实现限流操作,QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合: 1.批量处理大数据。...

    Java简单线程池 线程池中文文档

    简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类

    java多线程分页查询

    ### Java多线程分页查询知识点详解 #### 一、背景与需求分析 在实际的软件开发过程中,尤其是在处理大量数据时,如何高效地进行数据查询成为了一个关键问题。例如,在一个用户众多的社交平台上,当用户需要查看...

    java多线程查询数据库

    综上所述,"java多线程查询数据库"是一个涉及多线程技术、线程池管理、并发控制、分页查询等多个方面的复杂问题。通过理解和掌握这些知识点,我们可以有效地提高数据库操作的效率和系统的响应速度。

    Java多线程编程总结

    Java线程:新特征-线程池 Java线程:新特征-有返回值的线程 Java线程:新特征-锁(上) Java线程:新特征-锁(下) Java线程:新特征-信号量 Java线程:新特征-阻塞队列 Java线程:新特征-阻塞栈 Java线程:新特征-...

    java多线程学习-ftp上传

    Java多线程学习是编程领域中的重要一环,特别是在服务器端和网络编程中,多线程技术能够有效地利用系统资源,提高程序的并发性。FTP(File Transfer Protocol)上传则是通过网络将本地文件传输到远程服务器的过程。...

    Java多线程编程,生命游戏,用线程池.zip

    Java多线程编程,生命游戏,用线程池.zipJava多线程编程,生命游戏,用线程池.zip Java多线程编程,生命游戏,用线程池.zipJava多线程编程,生命游戏,用线程池.zip Java多线程编程,生命游戏,用线程池.zipJava多...

    java基础--11.多线程-1

    在Java编程语言中,多线程是核心特性之一,它允许程序同时执行多个任务,从而提高了应用程序的效率和响应性。本节我们将深入探讨Java中的多线程概念,包括其重要性、创建方法以及相关机制。 一、多线程的重要性 1....

    JAVA使用线程池查询大批量数据

    除了`ThreadPoolExecutor`,Java还提供了`Executors`工具类,它提供了一些预设的线程池配置,如`newFixedThreadPool`(固定大小线程池)、`newSingleThreadExecutor`(单线程线程池)等,方便开发者快速创建线程池。...

    java多线程的讲解和实战

    Java多线程是Java编程中的重要概念,尤其在如今的多核处理器环境下,理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理,并提供了丰富的实战代码,非常适合Java初学者...

    java多线程加队列上传文件_后台处理

    ### Java多线程加队列上传文件_后台处理 #### 概述 本文将详细介绍一个基于Java实现的多线程文件上传系统,并结合队列管理技术来优化后台处理流程。该系统通过创建多个线程来并行处理客户端的文件上传请求,同时...

    Java多线程知识点总结

    总之,掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题,比如资源竞争、死锁、线程安全性等问题,至关重要。在实际开发中,...

    Java多线程编程实战指南-核心篇

    《Java多线程编程实战指南-核心篇》是一本深入探讨Java并发编程的书籍,旨在帮助读者掌握在Java环境中创建、管理和同步线程的核心技术。Java的多线程能力是其强大之处,使得开发者能够在同一时间执行多个任务,提高...

Global site tag (gtag.js) - Google Analytics