`

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多线程,对多线程,线程池进行封装,方便使用

    Java多线程是Java编程中的重要概念,它允许程序同时执行多个任务,提高了程序的效率和响应速度。在Java中,我们可以通过实现Runnable接口或继承Thread类来创建线程。然而,直接使用线程可能存在一些问题,如资源管理...

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

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

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

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

    线程-线程池-锁-集合-Map-队列.docx

    综上所述,线程、线程池、集合和队列是Java并发编程的核心概念,理解和掌握它们对于开发高效、稳定的并发应用程序至关重要。在实际开发中,应根据具体需求选择合适的线程管理策略、数据结构和同步机制,以实现高性能...

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

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

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

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

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

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

    java多线程分页查询

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

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

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

    java多线程查询数据库

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

    Java-Thread-Affinity,将Java线程绑定到给定的内核.zip

    2. **线程池支持**:可能扩展了`java.util.concurrent.ExecutorService`接口,使得线程池中的线程也可以根据策略绑定到特定的核心。 3. **平台兼容性**:考虑到跨平台兼容性,该项目可能实现了对Linux、Windows、...

    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多线程实现大批量数据导入源码

    总的来说,本项目通过Java多线程技术,结合合理的数据切分和线程池管理,实现对大数据的高效批量处理。通过分析和优化这些关键点,我们可以根据实际情况调整参数,进一步提高数据导入导出的效率。

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

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

    java多线程的讲解和实战

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

Global site tag (gtag.js) - Google Analytics