多线程基础知识总结三---线程池

线程池

线程池概念

创建一些线程，这些线程的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时便创建大量空闲线程，程序分配一个任务给线程池，线程池就会启动一条线程来执行该任务，执行完后，该线程并不死亡，而是再次返回线程池等待执行下一个任务。

线程池工作机制

线程池编程模式下，任务被提交给整个线程池而不是交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，有的话，则将任务交给某个空闲的线程；一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

使用线程池的原因

多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过度消耗系统资源，以及过度切换线程可能导致系统资源崩溃。

四种常见的线程池

1.Executors.newCacheThreadPool()

缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务。线程池无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不是每次新建线程。
示例代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CacheThreadPool {
	public static void main(String []args){
	    //创建一个可缓存的线程池
		ExecutorService es= Executors.newCachedThreadPool();
		for(int i=0;i<10;i++){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			es.execute(new Runnable(){
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName()+"正在执行");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}
}

2.Executors.newFixedThreadPool(int n)

创建一个可重用固定个数的线程池，大小为n，以共享的无界队列方式来运行这些线程，定长线程池的大小最好根据系统资源进行设置。
示例代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPool {
	public static void main(String []args){
		ExecutorService es=Executors.newFixedThreadPool(4);
		for(int i=0;i<10;i++){
			es.execute(new Runnable(){
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName()+"正在执行");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}
}

3.Executors.newScheduledThreadPool(int n)

创建一个定长线程池，支持定时及周期性任务执行，n表示线程池的大小
示例代码

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPool {
	public static void main(String []args){
		//创建一个定长为4的线程池
		ScheduledExecutorService es=Executors.newScheduledThreadPool(4);
	   //延迟一秒执行
		/*
		es.schedule(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("延迟了5秒才执行");
			}
		}, 5, TimeUnit.SECONDS);
		//es.schedule(Runnable(),延长时间,时间单元)  只执行一次
		*/
		
		es.scheduleAtFixedRate(new Runnable(){
			@Override
			public void run() {
				System.out.println("延迟1秒后每3秒执行一次，当前线程："+Thread.currentThread().getName());
			}
		}, 1, 3, TimeUnit.SECONDS);
		//es.schedule(Runnable(),延长时间,间隔时间,时间单元)  不断执行
	}
}

4.Executors.newSingleThreadExecutor()

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutor {
	public static void main(String []args){
		ExecutorService es=Executors.newSingleThreadExecutor();
		for(int i=0;i<10;i++){
			final int index=i;
			es.execute(new Runnable(){
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(Thread.currentThread().getName()+"是第："+index+"个线程");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}		
			});
		}
	}
}

参考网址