java中的线程池有哪些，分别有什么作用？

傷城~ 2023-10-03 12:44 60阅读 0赞

### java中的线程池有哪些，分别有什么作用？ ###

**1.进程-线程简单介绍  
2.java的线程池是什么，有哪些类型，作用分别是什么  
3.使用线程池的优点**

**1.进程-线程的简单介绍**  
进程

什么是进程呢？

**进程**是计算机中的程序关于某数据集合的一次运行活动，是系统进行资源分配的调度的基本单位，是操作系统结构的基础。简单来讲：进程是指运行中的应用程序，进程是一个实体，每一个进程都有它自己的地址空间。例如我们点击了QQ，就启动了一个进程，操作系统就会为这个进程分配独立的地址空间，当我们又点击浏览器，这样又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。

线程

**什么是线程呢？**

**线程**是操作系统能够进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一个进程至少有一个线程。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。注意：线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属于一个进程的其他线程共享进程所拥有的全部资源，线程有就绪，阻塞，运行三种基本状态。

另外：在Unix System和SunOS中也被称为轻量进程，但轻量进程更多指内核线程，而把用户线程称为线程。

**2.java的线程池是什么，有哪些类型，作用分别是什么?**  
线程池是一种多线程处理形式，处理过程中将任务添加队列，然后在创建线程后自动启动这些任务，每个线程都使用默认的堆栈大小，以默认的优先级运行，并处在多线程单元中，如果某个线程在托管代码中空闲，则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后辅助线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才能启动。

java里面的线程池的顶级接口是Executor，Executor并不是一个线程池，而只是一个执行线程的工具，而真正的线程池是ExecutorService。

### java中的有哪些线程池？ ###

**1.newCachedThreadPool创建一个可缓存线程池程  
2.newFixedThreadPool 创建一个定长线程池  
3.newScheduledThreadPool 创建一个周期性执行任务的线程池  
4.newSingleThreadExecutor 创建一个单线程化的线程池**

下面一一分析：

**1.newCachedThreadPool**是一种线程数量不定的线程池，并且其最大线程数为Integer.MAX\_VALUE，这个数是很大的，一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。但是线程池中的空闲线程都有超时限制，这个超时时长是60秒，超过60秒闲置线程就会被回收。调用execute将重用以前构造的线程(如果线程可用)。这类线程池比较适合执行大量的耗时较少的任务，当整个线程池都处于闲置状态时，线程池中的线程都会超时被停止。

**实例代码：**

public class PoolExecutorTest {
        
     
    	public static void main(String[] args) {
        
    		// TODO Auto-generated method stub
    		
    		ExecutorService mCachelThreadPool = Executors.newCachedThreadPool();
    		
    		for(int i = 0;i < 7;i++ ) {
        
    			final int index = i;
    			try {
        
    				Thread.sleep(2000);
    			} catch (InterruptedException e) {
        
    				e.printStackTrace();
    			}
    			mCachelThreadPool.execute(new Runnable() {
        
    				
    				@Override
    				public void run() {
        
    					System.out.println("第" +index +"个线程" +Thread.currentThread().getName()); 
    				}
    			});
    			
    		}
    		
     
    	}
     
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70]  
从结果可以看到，执行第二个任务的时候第一个任务已经完成，会复用执行第一个任务的线程，不用每次新建线程。

**2.newFixedThreadPool** 创建一个指定工作线程数量的线程池，每当提交一个任务就创建一个工作线程，当线程 处于空闲状态时，它们并不会被回收，除非线程池被关闭了，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列（没有大小限制）中。由于newFixedThreadPool只有核心线程并且这些核心线程不会被回收，这样它更加快速底相应外界的请求。

**实例代码：**

public class PoolExecutorTest {
        
     
    	public static void main(String[] args) throws InterruptedException {
        
    		// TODO Auto-generated method stub
    		//设置最大线程数5个
    		ExecutorService mFixedThreadPool = Executors.newFixedThreadPool(5);
    		
    		for(int i = 0;i < 7;i++ ) {
        
    			final int index = i;
    			mFixedThreadPool.execute(new Runnable() {
        
    				
    				@Override
    				public void run() {
        
    					System.out.println("时间是:"+System.currentTimeMillis()+"第" +index +"个线程" +Thread.currentThread().getName()); 
    					try {
        
    						Thread.sleep(2000);
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}	
    				 }
    			});
    			
    		}
    		
     
    	}
     
    }

输出结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70 1]  
由于设置最大线程是5，所以当执行完这5个线程后，等待两秒后，在执行后面2个线程。

**3.newScheduledThreadPool** 创建一个线程池，它的核心线程数量是固定的，而非核心线程数是没有限制的，并且当非核心线程闲置时会被立即回收，它可安排给定延迟后运行命令或者定期地执行。这类线程池主要用于执行定时任务和具有固定周期的重复任务。

**延迟执行实例代码：**

public class PoolExecutorTest {
        
     
    	public static void main(String[] args) throws InterruptedException {
        
    		// TODO Auto-generated method stub
    		
    		//设置池中核心数量是2
            ScheduledExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(2);  
            System.out.println("现在的时间:"+System.currentTimeMillis());
            mScheduledThreadPool.schedule(new Runnable() {
        
    			
    			@Override
    			public void run() {
        
    				// TODO Auto-generated method stub
    				System.out.println("现在的时间:"+System.currentTimeMillis());
    				
    			}
    		}, 4, TimeUnit.SECONDS);//这里设置延迟4秒执行
    		
     
    	}
     
    }

执行的结果如下：  
![在这里插入图片描述][eaab4ba647b043adbd6c90811c49f6ca.png]  
误差可以忽略，实际结果确实延迟了4秒执行。

**定期执行示例代码**

public class PoolExecutorTest {
        
     
    	public static void main(String[] args) throws InterruptedException {
        
    		// TODO Auto-generated method stub
    		
    		//设置池中核心数量是2
            ScheduledExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(2);  
            System.out.println("现在的时间:"+System.currentTimeMillis());
            mScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
        
    			
    			@Override
    			public void run() {
        
    				// TODO Auto-generated method stub
    				System.out.println("现在的时间:"+System.currentTimeMillis());
    				
    			}
    		}, 2, 3,TimeUnit.SECONDS);//这里设置延迟2秒后每3秒执行一次
    		
     
    	}
     
    }

执行的结果如下：  
![在这里插入图片描述][ef0c3d6424604403bc3cf054e259aee5.png]  
可发现确实延迟2秒后每隔3秒后就会执行一次，程序不退出就一直执行下去。

**4.newSingleThreadExecutor**这类线程池内部只有一个核心线程，以无界队列方式来执行该线程，这使得这些任务之间不需要处理线程同步的问题，它确保所有的任务都在同一个线程中按顺序中执行，并且可以在任意给定的时间不会有多个线程是活动的。

示例代码：

public class PoolExecutorTest {
        
     
    	public static void main(String[] args) throws InterruptedException {
        
    		// TODO Auto-generated method stub
    		
    		ExecutorService mSingleThreadPool = Executors.newSingleThreadExecutor();     
            for(int i = 0;i < 7;i++) {
        
            	final int number = i;
            	mSingleThreadPool.execute(new Runnable() {
        
    				
    				@Override
    				public void run() {
        
    					System.out.println("现在的时间:"+System.currentTimeMillis()+"第"+number+"个线程");
    	                try {
        
    						Thread.sleep(2000);
    					} catch (InterruptedException e) {
        
    						e.printStackTrace();
    					}
    					
    				}
    			});
            	
            }
     
    	}
     
    }

执行的结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70 2]  
可发现是有顺序地去执行上面6个线程。

### 3.使用线程池的优点 ###

1.重用线程池的线程，避免因为线程的创建和销毁锁带来的性能开销

2.有效控制线程池的最大并发数，避免大量的线程之间因抢占系统资源而阻塞

3.能够对线程进行简单的管理，并提供一下特定的操作如：可以提供定时、定期、单线程、并发数控制等功能

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/d697c83845ed4d9092cb334df06a8505.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/4bf99be099de4611867d84c4b6d63082.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz,size_16,color_FFFFFF,t_70
[eaab4ba647b043adbd6c90811c49f6ca.png]: https://img-blog.csdnimg.cn/eaab4ba647b043adbd6c90811c49f6ca.png
[ef0c3d6424604403bc3cf054e259aee5.png]: https://img-blog.csdnimg.cn/ef0c3d6424604403bc3cf054e259aee5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/662e3ec592024047bb3309593eece8b2.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzODQyMDkz,size_16,color_FFFFFF,t_70