Executors类主要方法：
a. static ExecutorService newCachedThreadPool()
产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用
b. static ExecutorService newFixedThreadPool(int poolSize)
产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行
c. static ExecutorService newSingleThreadExecutor()
产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
一．static ExecutorService newFixedThreadPool(int poolSize)：创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。
实例1：
package com.bijian.thread;
public class MyThread extends Thread {
private String nickName;
public MyThread(String nickName) {
super();
this.nickName = nickName;
}
@Override
public void run() {
try {
Thread.sleep(50);
} catch(Exception e) {
}
System.out.println(Thread.currentThread().getName() + ": "+ nickName + "正在执行。。。");
try {
Thread.sleep(100);
} catch(Exception e) {
}
}
}
package com.bijian.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//pool.exe
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-2: B正在执行。。。 pool-1-thread-1: A正在执行。。。 pool-1-thread-2: C正在执行。。。 pool-1-thread-1: D正在执行。。。 pool-1-thread-1: E正在执行。。。
二．static ExecutorServicenewSingleThreadExecutor()：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
实例2（修改Main类如下）：
package com.bijian.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程
ExecutorService pool = Executors.newSingleThreadExecutor();
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-1: A正在执行。。。 pool-1-thread-1: B正在执行。。。 pool-1-thread-1: C正在执行。。。 pool-1-thread-1: D正在执行。。。 pool-1-thread-1: E正在执行。。。
三．static ExecutorServicenewCachedThreadPool()：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
实例3（修改Main类如下）：
package com.bijian.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们
ExecutorService pool = Executors.newCachedThreadPool();
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
try {
Thread.sleep(4000);
} catch(Exception e) {
}
Thread t6 = new MyThread("F");
pool.execute(t6);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-1: A正在执行。。。 pool-1-thread-5: E正在执行。。。 pool-1-thread-4: D正在执行。。。 pool-1-thread-2: B正在执行。。。 pool-1-thread-3: C正在执行。。。 pool-1-thread-1: F正在执行。。。
四．static ScheduledExecutorServicenewScheduledThreadPool(int corePoolSize): 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
ScheduledExecutorService接口方法：
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)：创建并执行在给定延迟后启用的一次性操作。
实例4（修改Main类如下）：
package com.bijian.thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
//1000毫秒后执行t4线程
pool.schedule(t4, 1000, TimeUnit.MILLISECONDS);
//1000毫秒后执行t5线程
pool.schedule(t5, 1000, TimeUnit.MILLISECONDS);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-2: B正在执行。。。 pool-1-thread-1: A正在执行。。。 pool-1-thread-1: C正在执行。。。 pool-1-thread-2: D正在执行。。。 pool-1-thread-1: E正在执行。。。
五．static ScheduledExecutorServicenewSingleThreadScheduledExecutor()：创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
实例5（修改Main类如下）：
package com.bijian.thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行
ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.schedule(t4, 5000, TimeUnit.MILLISECONDS);
pool.schedule(t5, 1000, TimeUnit.MILLISECONDS);
//关闭线程池
pool.shutdown();
}
}
运行结果：
pool-1-thread-1: A正在执行。。。 pool-1-thread-1: B正在执行。。。 pool-1-thread-1: C正在执行。。。 pool-1-thread-1: E正在执行。。。 pool-1-thread-1: D正在执行。。。
六.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) :用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。
实例6（修改Main类如下）：
package com.bijian.thread;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
//创建等待队列
BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
//用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);
//创建实现了Runnable 接口对象，Thread 对象当然也实现了Runnable 接口
Thread t1 = new MyThread("A");
Thread t2 = new MyThread("B");
Thread t3 = new MyThread("C");
Thread t4 = new MyThread("D");
Thread t5 = new MyThread("E");
Thread t6 = new MyThread("F");
Thread t7 = new MyThread("G");
bqueue.add(t7);
bqueue.add(t2);
bqueue.add(t3);
bqueue.add(t1);
bqueue.add(t5);
bqueue.add(t6);
bqueue.add(t4);
bqueue.add(t1);
//关闭线程池
pool.shutdown();
}
}
运行结果（线程池依次执行队列中的线程对象）：
pool-1-thread-1: G正在执行。。。 pool-1-thread-1: B正在执行。。。 pool-1-thread-1: C正在执行。。。 pool-1-thread-1: A正在执行。。。 pool-1-thread-1: E正在执行。。。 pool-1-thread-1: F正在执行。。。 pool-1-thread-1: D正在执行。。。 pool-1-thread-1: A正在执行。。。
JDK1.5自带线程池的好处：
a. 分配线程、线程使用完回收至线程池、线程池没有线程可分配等待这些工作都是自动完成的
b. 方法的操作非常简便
相关推荐
JDK 1.5引入了java.util.concurrent包，其中包含了线程池的实现，使得并发编程更加便捷和高效。线程池的核心在于它的设计策略，包括核心线程数、最大线程数、线程存活时间、工作队列以及拒绝策略。 线程池的主要类...
JDK1.5的线程池讲解，示例代码，很精辟～
JDK1.5中的线程池(ThreadPoolExecutor)使用简介
对于并发编程，JDK1.5引入了java.util.concurrent包，其中包括了线程池、Future、Callable接口以及CyclicBarrier和Semaphore等同步工具类，极大地丰富了并发处理能力，提升了多线程环境下的性能和可维护性。...
在并发处理上，JDK1.5引入了并发工具类（java.util.concurrent），包括线程池（ExecutorService）、并发容器（如ConcurrentHashMap）以及Future接口等，这些工具极大地提高了多线程环境下的程序设计效率和性能。...
资源很不错
JDK1.5，也被称为Java SE 5.0，是Oracle公司于2004年发布的一个重大更新，带来了许多重要的新特性、改进和优化。以下是对这个版本的一些关键知识点的详细解释： 1. **泛型（Generics）**：JDK1.5引入了泛型，使得...
使用jdk1.5 实现的线程池. 可以定制人物和其它特性. 下载后可以自己进行相关功能完善. 欢迎加QQ:934547801一起讨论
安装程序"jdk1.5 for windows（32位）安装程序.exe"将引导用户完成配置步骤，包括选择安装目录、设置环境变量（如JAVA_HOME、PATH和CLASSPATH）以及选择是否创建桌面快捷方式。 请注意，由于JDK 1.5已经过时，可能...
**JDK1.5免安装详解** Java Development Kit（JDK）是Oracle公司提供的用于开发和运行Java应用程序的工具集合。JDK1.5，也称为Java 5.0，是一个重要的版本，它引入了许多创新特性，提升了Java编程的效率和性能。...
标题"jdk1.5 and tomcat5.5"指的是Java Development Kit (JDK) 1.5版本与Apache Tomcat 5.5版本的组合。这两个组件是开发和运行Java应用程序的关键工具，特别是对于Web应用程序。 描述中提到的"jdk-1_5_0_22-...
JDK 1.5的内存模型和并发工具也得到了增强，添加了如`java.util.concurrent`包，其中包含了线程池、同步容器、并发队列等高效并发编程工具，极大地提升了多线程环境下应用程序的性能和可维护性。 至于文件列表中的`...
**Java Development Kit (JDK) 1.5.0.22 64位详解** JDK（Java Development Kit）是Oracle公司发布的用于开发、编译、调试Java应用程序的工具集合。版本1.5.0.22是JDK的一个历史版本，也被称为Java 5.0 Update 22，...
JDK 1.5是Java历史上的一个重要版本，发布于2004年，正式名称为Java SE 5.0（Java Standard Edition 5.0）。这个版本引入了许多新特性，对Java语言进行了重大改进，极大地提升了开发效率和代码质量。 1. **泛型...
JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介
JDK 1.5 引入了一系列重要的并发编程新特性，极大地改善了多线程环境下的程序设计。这些特性使得开发者能够编写更加高效、安全的并发应用程序。以下是对这些新特性的详细解释： 1. `TimeUnit`： `TimeUnit` 是一个...
在Java编程语言中，线程并发和线程池是多任务执行的核心概念，尤其是在JDK 1.5及以后的版本中得到了显著增强。线程并发允许程序同时执行多个任务，提高了程序的效率和响应性。线程池是管理线程资源的有效方式，通过...
《Java JDK1.5实例宝典》是一本深入解析JDK1.5版本中关键特性和类库的实践指南，涵盖了Java Mail、Servlet、JSP以及多线程等多个核心领域。这本书通过丰富的实例来帮助读者理解和掌握Java编程的精髓。 在JDK1.5中，...
"JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用" JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用是Java多线程编程中的一种重要概念。随着多线程编程的普及，线程池的使用变得...
在并发处理方面，JDK1.5引入了并发工具包（java.util.concurrent），包括线程池、并发容器和同步原语等，提供了高效且易于使用的多线程编程工具，大大改善了Java的并发性能。 最后，JDK1.5对垃圾回收机制进行了优化...