JAVA线程池应用实践

偏执的太偏执、 2022-06-12 05:08 212阅读 0赞

## 0.引言 ##

在上一篇文章：[http://blog.csdn.net/jin\_kwok/article/details/74898102][http_blog.csdn.net_jin_kwok_article_details_74898102] 中，我简单介绍过线程和多线程，在这里，我将详细介绍一下内容： 线程的创建方法和线程池的应用。

## 1.线程的创建方法 ##

###   1.1.【继承Thread类，覆写run()方法】 ###

如下代码所示，扩展了Thread类，并覆写了run方法，run()方法的内容就是线程获得CPU资源后所执行的部分，称为执行体，如下面的示例代码：执行步骤为：

1.创建MyThread类实例，也就是创建线程对象；

2.调用start()方法，是线程处于\[就绪\]状态，并一定会立即执行，而是需要等待CPU调度；

public class ThreadIntroduction {
    
    	public static void main(String[] args)
    	{
    		for(int index=0;index<3;index++)
    		{
    			MyThread thread=new MyThread("just for a test");
    			thread.start();	
    		}
    	}
    }
    
    class MyThread extends Thread
    {
    	//自定义
    	private String description;
    	public MyThread(String description)
    	{
    		this.description=description;		
    	}
    	
    	@Override
    	public void run()
    	{
    		System.out.println(description);
    		
    		for(int i=0;i<5;i++)
    		{
    			System.out.println(Thread.currentThread().getName()+": ["+i+"]");
    		}
    	}
    }

某次运行结果 ：

![Image 1][]![Center][]

###  1.2.【实现Runnable接口】 ###

Runnable接口中也有一个run()方法，同样是作为线程的执行体，因此，用户可以根据需要在其中填写代码，Runnable接口的实现类并不能作为一个线程直接启动，而是作为Thread类的target，再经由Thread对象类启动：

1.实现Runnable接口，自定义run()方法内容；

2.创建Runnable接口实现类对象；

3.将Runnable接口实现类对象作为target，创建Thread类对象；

4.调用start()；

public class ThreadIntroduction {
    
    	public static void main(String[] args)
    	{
    		for(int index=0;index<3;index++)
    		{
    			RunnableThread runnablethread=new RunnableThread("just for a Runnable Interface test");
    			//Runnable接口实现类对象作为Thread类的target，创建Thread类对象
    			new Thread(runnablethread).start();
    		}
    	}
    }
    
    class RunnableThread implements Runnable
    {
    	//自定义
    	private String description;
    	public RunnableThread(String description)
    	{
    		this.description=description;		
    	}
    	
    	@Override
    	public void run()
    	{
    		System.out.println(description);
    		
    		for(int i=0;i<5;i++)
    		{
    			System.out.println(Thread.currentThread().getName()+": ["+i+"]");
    		}
    	}
    }

某次运行结果 ：

![Image 1][]![Center 1][]

###   1.3.【通过Callable接口和Future创建线程】 ###

1. 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

2. 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

3. 使用FutureTask对象作为Thread对象的target创建并启动新线程。

4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

public class ThreadIntroduction {
    
    	public static void main(String[] args)
    	{
    		//2.创建实现Callable的类的对象
    		MyCallableThread callablethread=new MyCallableThread();
    		//3.用FutureTask包装实现了Callable接口的类的对象
    		FutureTask<String> ft=new FutureTask<String>(callablethread);
    		//4.将包装后的对象作为target，创建Thread对象，并调用start
    		new Thread(ft).start();
    		
    		try 
    		{
    			System.out.println(Thread.currentThread().getName()+":"+ft.get());
    		} catch (InterruptedException | ExecutionException e) {
    			e.printStackTrace();
    		}
    		
    	}
    }
    
    //1.创建实现Callable的类，并实现call方法
    class MyCallableThread implements Callable<String>
    {
    
    	@Override
    	public String call() throws Exception
    	{	
    		for(int i=0;i<5;i++)
    		{
    			System.out.println(Thread.currentThread().getName()+": ["+i+"]");
    		}
    		return "just a test for Callable interface.";
    	}
    	
    }

某次运行结果 ：

![Image 1][]![Center 2][]

## 2.线程池 ##

在第一节中介绍了三种创建线程的方式，这些线程从创建到结束(new->dead)，生命周期很短，如果频繁的创建线程，其创建和销毁将会大量消耗系统资源，相应地，使用线程池则有诸多好处：

<1>：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

<2>：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

<3>：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。

###  2.1 java线程池核心类ThreadPoolExecutor ###

首先看一下 ThreadPoolExecutor类的构造函数：

public ThreadPoolExecutor(int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            TimeUnit unit,
            BlockingQueue<Runnable> workQueue)

其参数的意义分别为：

<1>corePoolSize：核心线程池的大小，即核心线程池所能容纳的线程数量上限 ，当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建，超过核心线程池数量的任务将会被保存到阻塞队列(work Queue )中；

<2>maximumPoolSize:线程池的最大线程容量，如果阻塞队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果；

<3>keepAliveTime:默认情况下，只对池中非核心线程起作用，非核心线程在没有任务可执行的情况下的最大保持时间，换言之，当任务很少的时候，处于“空闲状态”的非核心线程将被辞退，销毁，池中线程数量保持为核心线程数。但是，如果调用了allowCoreThreadTimeOut(boolean)方法，空闲的核心线程也会被销毁；

<4>workQueue：一个阻塞队列，用来存储等待执行的任务，当任务占满核心线程容限，新到来的任务将存储于阻塞队列中，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，阻塞队列有多种类型可选；

<5>unit:keepAliveTime的单位：ns，ms，s,m....

<6> RejectedExecutionHandler handler: 任务拒绝策略

<7> ThreadFactory threadFactory: 线程工厂，用来创建线程

<8> completedTaskCount: 用来记录已经执行完毕的任务个数

【注意：】当任务过多时的流程：核心线程满—>阻塞队列满—>最大线程满—>异常处理(拒绝接受任务)

用一个图来表示线程池的用法：

![Java_E7_BA_BF_E7_A8_8B_E6_B1_A0_E4_B8_BB_E8_A6_81_E5_B7_A5_E4_BD_9C_E6_B5_81_E7_A8_8B.jpg][]

###  2.2 线程池应用举例 ###

public class MainClassForTest {
    
    	public static void main(String[] args) 
    	{
    		int corePoolSize=2;
            int maximumPoolSize=4;
            long keepAliveTime=20;
            TimeUnit unit=TimeUnit.SECONDS;
            BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<Runnable>(2);
            
    		ThreadPoolExecutor pool =new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 
    				keepAliveTime, unit, workQueue);	
    		
    		//创建6个任务，并将其加入到线程池中
    		for(int i=0;i<6;i++)
    		{
    			//创建自定义任务实例
    			MyRunnable task=new MyRunnable("ID["+i+"]");
    			//加入到线程池
    			pool.execute(task);
    			
    			System.out.println("当前任务数量："+pool.getTaskCount());
    			System.out.println("当前池中线程数量："+pool.getPoolSize());
    			System.out.println("当前阻塞队列中任务数量："+pool.getQueue().size());		
    		}		
    	}
    }
    
    /**
     * 实现Runnable接口，创建自定义任务类MyRunnable
     */
    class MyRunnable implements Runnable
    {
    	private String id;
    	public MyRunnable(String id)
    	{
    		this.id=id;
    	}
    	@Override
    	public void run() 
    	{	
    		try{
    			Thread.sleep(1000L);
    		}catch( InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    		
    		System.out.println(Thread.currentThread().getName()+":"+id);
    		
    	}
    	
    }

【上面代码某次运行结果】：

![Center 3][]

![Image 1][]

【注意:】应该注意到，上述例子的代码中：创建的任务总数=最大线程数+阻塞队列容限，正因为满足这一条，上述代码运行中并没有出现拒绝接受任务的异常，但是，实际中难免出现，怎么处理呢？

### 2.3.异常处理 ###

当并发任务数量>线程池最大线程数+阻塞队列容限，就会出现以下异常：拒绝执行任务

![Center 4][]

![Image 1][]

为了避免上述异常，我们一般在阻塞队列这个参数上做文章,阻塞队列有几种类型可选：

<1> ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

<2> LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

<3>SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

<4>PriorityBlockingQueue：一个具有优先级得无限阻塞队列。

为了避免出现拒绝任务的异常，一般将队列的容限设置一个较大值，此外，有四种异常处理模式可选：

(1) 默认的ThreadPoolExecutor.AbortPolicy：处理程序遭到拒绝将抛出运行时RejectedExecutionException;  
  (2) ThreadPoolExecutor.CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

(3) ThreadPoolExecutor.DiscardPolicy：不能执行的任务将被删除;

(4) ThreadPoolExecutor.DiscardOldestPolicy ：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

在上面例子中加上一行代码，设置异常处理模式：

public static void main(String[] args) 
    	{
    		int corePoolSize=2;
            int maximumPoolSize=4;
            long keepAliveTime=20;
            TimeUnit unit=TimeUnit.SECONDS;
            BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<Runnable>(2);
            
    		ThreadPoolExecutor pool =new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 
    				keepAliveTime, unit, workQueue);
    		//设置异常处理模式
    		pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    		//创建8个任务，并将其加入到线程池中
    		for(int i=0;i<8;i++)
    		{
    			//创建自定义任务实例
    			MyRunnable task=new MyRunnable("ID["+i+"]");
    			//加入到线程池
    			pool.execute(task);
    			
    			System.out.println("当前任务数量："+pool.getTaskCount());
    			System.out.println("当前池中线程数量："+pool.getPoolSize());
    			System.out.println("当前阻塞队列中任务数量："+pool.getQueue().size());		
    		}		
    	}

此外，我们也可以通过实现RejectedExecutionHandler接口，自定义异常处理；

class MyRejectedExecutionHandler implements RejectedExecutionHandler
    {
    
    	@Override
    	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor)
    	{
    		// TODO Auto-generated method stub
    		
    	}
    
    }

参考文献：

1.[http://www.importnew.com/19011.html][http_www.importnew.com_19011.html]

2.[http://www.cnblogs.com/mengdd/archive/2013/02/16/2913649.html][http_www.cnblogs.com_mengdd_archive_2013_02_16_2913649.html]

3.[http://ifeve.com/java-threadpool/][http_ifeve.com_java-threadpool]

4.[http://blog.csdn.net/pfnie/article/details/52810454][http_blog.csdn.net_pfnie_article_details_52810454]

[http_blog.csdn.net_jin_kwok_article_details_74898102]: http://blog.csdn.net/jin_kwok/article/details/74898102
[Image 1]: 
[Center]: /images/20220612/61100447114d45ad9f83d2d491b17a19.png
[Center 1]: /images/20220612/c9555fbe89364205849cb81504d7d8f7.png
[Center 2]: /images/20220612/4dea3d2c73474ecd87f038ae9700a4f6.png
[Java_E7_BA_BF_E7_A8_8B_E6_B1_A0_E4_B8_BB_E8_A6_81_E5_B7_A5_E4_BD_9C_E6_B5_81_E7_A8_8B.jpg]: /images/20220612/2bdb7bbf2f6043c3b8b4fd91578773ad.png
[Center 3]: /images/20220612/697c031a87ac489a9f132ab3fb0f4d0f.png
[Center 4]: /images/20220612/2dfb2e158c1f4eafb4304097ec0f7b02.png
[http_www.importnew.com_19011.html]: http://www.importnew.com/19011.html
[http_www.cnblogs.com_mengdd_archive_2013_02_16_2913649.html]: http://www.cnblogs.com/mengdd/archive/2013/02/16/2913649.html
[http_ifeve.com_java-threadpool]: http://ifeve.com/java-threadpool/
[http_blog.csdn.net_pfnie_article_details_52810454]: http://blog.csdn.net/pfnie/article/details/52810454