JDK1.5 线程池

 

 

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.       方法的操作非常简便