AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

Java:使用Executors创建和管理线程

2017-11-16 1035
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
1.  类  Executors

此类中提供的一些方法有：
1.1 public static ExecutorService newCachedThreadPool()

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。
 
1.2 public static ExecutorService newFixedThreadPool(int nThreads)

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
 
1.3 public static ExecutorService newSingleThreadExecutor()

创建一个使用单个  worker  线程的  Executor ，以无界队列方式来运行该线程。
 
这三个方法都可以配合接口 ThreadFactory 的实例一起使用。并且返回一个 ExecutorService 接口的实例。
2.  接口  ThreadFactory

根据需要创建新线程的对象。使用线程工厂就无需再手工编写对  new Thread  的调用了，从而允许应用程序使用特殊的线程子类、属性等等。
此接口最简单的实现就是：
class SimpleThreadFactory implements ThreadFactory {
   public Thread newThread(Runnable r) {
     return new Thread(r);
   }
 }
3.  接口 ExecutorService

该接口提供了管理终止的方法。
4. 创建标准线程池启动线程

4.1  提供一个简单的实现 Runnable 接口的线程

MyThread.java

package  com.zj.concurrency.executors;

 

public   class  MyThread  implements  Runnable {

     private   int   count  = 1,  number ;

 

     public  MyThread( int  num) {

        number  = num;

       System. out .println( "Create Thread-"  +  number );

    }

 

     public   void  run() {

        while  ( true ) {

           System. out .println( "Thread-"  +  number  +  " run "  +  count + " time(s)" );

            if  (++ count  == 3)

               return ;

       }

    }

}
这个线程会打印出相应的创建和执行信息。
 
4.2 使用 CachedThreadPool 启动线程

CachedThreadPool.java

package  com.zj.concurrency.executors;

import  java.util.concurrent.ExecutorService;

import  java.util.concurrent.Executors;

 

public   class  CachedThreadPool {

     public   static   void  main(String[] args) {

       ExecutorService exec = Executors.newCachedThreadPool();

        for  ( int  i = 0; i < 5; i++)

           exec.execute( new  MyThread(i));

       exec.shutdown();

    }

}
结果：
Create Thread-0

Create Thread-1

Create Thread-2

Create Thread-3

Thread-0 run 1 time(s)

Thread-0 run 2 time(s)

Thread-1 run 1 time(s)

Thread-1 run 2 time(s)

Thread-2 run 1 time(s)

Thread-2 run 2 time(s)

Create Thread-4

Thread-4 run 1 time(s)

Thread-4 run 2 time(s)

Thread-3 run 1 time(s)

Thread-3 run 2 time(s)
 
4.3  使用 FixedThreadPool 启动线程

FixedThreadPool.java

package  com.zj.concurrency.executors;

import  java.util.concurrent.ExecutorService;

import  java.util.concurrent.Executors;

 

public   class  FixedThreadPool {

     public   static   void  main(String[] args) {

       ExecutorService exec = Executors.newFixedThreadPool(2);

        for  ( int  i = 0; i < 5; i++)

           exec.execute( new  MyThread(i));

       exec.shutdown();

    }

}
结果：
Create Thread-0

Create Thread-1

Create Thread-2

Create Thread-3

Create Thread-4

Thread-0 run 1 time(s)

Thread-0 run 2 time(s)

Thread-2 run 1 time(s)

Thread-2 run 2 time(s)

Thread-3 run 1 time(s)

Thread-3 run 2 time(s)

Thread-4 run 1 time(s)

Thread-4 run 2 time(s)

Thread-1 run 1 time(s)

Thread-1 run 2 time(s)
 
4.4  使用 SingleThreadExecutor 启动线程

SingleThreadExecutor.java

package  com.zj.concurrency.executors;

import  java.util.concurrent.ExecutorService;

import  java.util.concurrent.Executors;

 

public   class  SingleThreadExecutor {

     public   static   void  main(String[] args) {

       ExecutorService exec = Executors.newSingleThreadExecutor();

        for  ( int  i = 0; i < 5; i++)

           exec.execute( new  MyThread(i));

       exec.shutdown();

    }

}
结果：
Create Thread-0

Create Thread-1

Create Thread-2

Create Thread-3

Create Thread-4

Thread-0 run 1 time(s)

Thread-0 run 2 time(s)

Thread-1 run 1 time(s)

Thread-1 run 2 time(s)

Thread-2 run 1 time(s)

Thread-2 run 2 time(s)

Thread-3 run 1 time(s)

Thread-3 run 2 time(s)

Thread-4 run 1 time(s)

Thread-4 run 2 time(s)
5. 配合 ThreadFactory 接口的使用

我们试图给线程加入 daemon 和 priority 的属性设置。
5.1 设置后台线程属性

DaemonThreadFactory.java

package  com.zj.concurrency.executors.factory;

import  java.util.concurrent.ThreadFactory;

 

public   class  DaemonThreadFactory  implements  ThreadFactory {

     public  Thread newThread(Runnable r) {

       Thread t =  new  Thread(r);

       t.setDaemon( true );

        return  t;

    }

}
 
5.2  设置优先级属性

最高优先级 MaxPriorityThreadFactory.java

package  com.zj.concurrency.executors.factory;

import  java.util.concurrent.ThreadFactory;

 

public   class  MaxPriorityThreadFactory  implements  ThreadFactory {

     public  Thread newThread(Runnable r) {

       Thread t =  new  Thread(r);

       t.setPriority(Thread. MAX_PRIORITY );

        return  t;

    }

}
最低优先级 MinPriorityThreadFactory.java

package  com.zj.concurrency.executors.factory;

import  java.util.concurrent.ThreadFactory;

 

public   class  MinPriorityThreadFactory  implements  ThreadFactory {

     public  Thread newThread(Runnable r) {

       Thread t =  new  Thread(r);

       t.setPriority(Thread. MIN_PRIORITY );

        return  t;

    }

}
 
5.3 启动带有属性设置的线程

ExecFromFactory.java

package  com.zj.concurrency.executors;

import  java.util.concurrent.ExecutorService;

import  java.util.concurrent.Executors;

import  com.zj.concurrency.executors.factory.DaemonThreadFactory;

import  com.zj.concurrency.executors.factory.MaxPriorityThreadFactory;

import  com.zj.concurrency.executors.factory.MinPriorityThreadFactory;

 

public   class  ExecFromFactory {

     public   static   void  main(String[] args)  throws  Exception {

       ExecutorService defaultExec = Executors.newCachedThreadPool();

       ExecutorService daemonExec = Executors

              .newCachedThreadPool( new  DaemonThreadFactory());

       ExecutorService maxPriorityExec = Executors

              .newCachedThreadPool( new  MaxPriorityThreadFactory());

       ExecutorService minPriorityExec = Executors

              .newCachedThreadPool( new  MinPriorityThreadFactory());

        for  ( int  i = 0; i < 10; i++)

           daemonExec.execute( new  MyThread(i));

        for  ( int  i = 10; i < 20; i++)

            if  (i == 10)

              maxPriorityExec.execute( new  MyThread(i));

            else   if  (i == 11)

              minPriorityExec. execute(new MyThread(i));

            else

              defaultExec.execute( new  MyThread(i));

    }

}
结果：
Create Thread-0

Create Thread-1

Create Thread-2

Create Thread-3

Thread-0 run 1 time(s)

Thread-0 run 2 time(s)

Thread-1 run 1 time(s)

Thread-1 run 2 time(s)

Thread-2 run 1 time(s)

Thread-2 run 2 time(s)

Create Thread-4

Thread-4 run 1 time(s)

Thread-4 run 2 time(s)

Create Thread-5

Thread-5 run 1 time(s)

Thread-5 run 2 time(s)

Create Thread-6

Create Thread-7

Thread-7 run 1 time(s)

Thread-7 run 2 time(s)

Create Thread-8

Thread-8 run 1 time(s)

Thread-8 run 2 time(s)

Create Thread-9

Create Thread-10

Thread-10 run 1 time(s)

Thread-10 run 2 time(s)

Create Thread-11

Thread-9 run 1 time(s)

Thread-9 run 2 time(s)

Thread-6 run 1 time(s)

Thread-6 run 2 time(s)

Thread-3 run 1 time(s)

Thread-3 run 2 time(s)

Create Thread-12

Create Thread-13

Create Thread-14

Thread-12 run 1 time(s)

Thread-12 run 2 time(s)

Thread-13 run 1 time(s)

Thread-13 run 2 time(s)

Create Thread-15

Thread-15 run 1 time(s)

Thread-15 run 2 time(s)

Create Thread-16

Thread-16 run 1 time(s)

Thread-16 run 2 time(s)

Create Thread-17

Create Thread-18

Create Thread-19

Thread-14 run 1 time(s)

Thread-14 run 2 time(s)

Thread-17 run 1 time(s)

Thread-17 run 2 time(s)

Thread-18 run 1 time(s)

Thread-18 run 2 time(s)

Thread-19 run 1 time(s)

Thread-19 run 2 time(s)

Thread-11 run 1 time(s)

Thread-11 run 2 time(s)


本文转自zhangjunhd51CTO博客，原文链接：http://blog.51cto.com/zhangjunhd/70068，如需转载请自行联系原作者
文章标签：
Java
关键词：
Java线程
executors线程
Java管理
Java Executors
线程管理
科技小先锋
目录
相关文章
凉凉心.
|
5月前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
269 1
凉凉心.
|
5月前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
285 1
小白学大数据
|
6月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
340 1
Java 数据库 Spring
248 0
蓝易云
|
6月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
436 16
艾伦~耶格尔
|
7月前
|
缓存 并行计算 安全
关于Java多线程详解
本文深入讲解Java多线程编程，涵盖基础概念、线程创建与管理、同步机制、并发工具类、线程池、线程安全集合、实战案例及常见问题解决方案，助你掌握高性能并发编程技巧，应对多线程开发中的挑战。
艾伦~耶格尔
469 0
小白学大数据
|
7月前
|
数据采集 存储 前端开发
Java爬虫性能优化：多线程抓取JSP动态数据实践
Java爬虫性能优化：多线程抓取JSP动态数据实践
小白学大数据
360 0
土木林森
|
存储 安全 Java
解锁Java并发编程奥秘：深入剖析Synchronized关键字的同步机制与实现原理，让多线程安全如磐石般稳固！
【8月更文挑战第4天】Java并发编程中，Synchronized关键字是确保多线程环境下数据一致性与线程安全的基础机制。它可通过修饰实例方法、静态方法或代码块来控制对共享资源的独占访问。Synchronized基于Java对象头中的监视器锁实现，通过MonitorEnter/MonitorExit指令管理锁的获取与释放。示例展示了如何使用Synchronized修饰方法以实现线程间的同步，避免数据竞争。掌握其原理对编写高效安全的多线程程序极为关键。
土木林森
332 1
丰宝宝
|
安全 Java 开发者
Java并发编程中的线程安全问题及解决方案探讨
在Java编程中，特别是在并发编程领域，线程安全问题是开发过程中常见且关键的挑战。本文将深入探讨Java中的线程安全性，分析常见的线程安全问题，并介绍相应的解决方案，帮助开发者更好地理解和应对并发环境下的挑战。【7月更文挑战第3天】
丰宝宝
376 0
wenxinx
|
安全 Java 开发者
Java并发编程中的线程安全策略
在现代软件开发中，Java语言的并发编程特性使得多线程应用成为可能。然而，随着线程数量的增加，如何确保数据的一致性和系统的稳定性成为开发者面临的挑战。本文将探讨Java并发编程中实现线程安全的几种策略，包括同步机制、volatile关键字的使用、以及java.util.concurrent包提供的工具类，旨在为Java开发者提供一系列实用的方法来应对并发问题。
wenxinx
185 0