java线程池四种简单案例

java线程池四种简单案例

一、固定线程池（固定线程个数）

使用 ExecutorService pool=Executors.newFixedThreadPool(3); 创建一个初始线程为3个的线程池 ，如果超过这个线程个数，后面的线程会等待

　　代码：

package demo;

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
/** 
 * 固定线程池 
 * 使用Executors.newFixedThreadPool(3)方法指定池中允许执行线程的个数 
 * 如果超过这个线程个数,后面的线程就会等待 
 */  
public class FixedThreadPoolTest {  
    public static void main(String[] args) {  
        //创建一个初始线程为3个的线程池  
        ExecutorService pool=Executors.newFixedThreadPool(3);  
        for(int i=0;i<3;i++){  
            final int task=i;  
            pool.execute(new Runnable() {  
                @Override  
                public void run() {  
                    try {  
                        Thread.sleep(20);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    for(int j=0;j<3;j++){  
                        System.out.println(Thread.currentThread().getName()+"正在进行第"+(task+1)+"个任务,第"+(j+1)+"次循环");  
                    }  
                }  
            });  
        }  
        //关闭线程池  
        pool.shutdown();  
    }  
} 

　　执行结果：

 二、缓存线程池（不固定线程个数，池中线程不够，会自动增加线程个数）

使用  ExecutorService pool=Executors.newCachedThreadPool();  创建一个缓存线程池

　　代码：

package demo;

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
/** 
 * 缓存线程池 
 * 如果池中的线程不够,会自动增加线程 
 */  
public class CachedThreadPoolTest {  
    public static void main(String[] args) {  
        //创建一个缓存线程池  
        ExecutorService pool=Executors.newCachedThreadPool();  
        for(int i=0;i<3;i++){  
            final int task=i;  
            pool.execute(new Runnable() {  
                @Override  
                public void run() {  
                    try {  
                        Thread.sleep(20);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    for(int j=0;j<3;j++){  
                        System.out.println(Thread.currentThread().getName()+"正在进行第"+(task+1)+"个任务,第"+(j+1)+"次循环");  
                    }  
                }  
            });  
        }  
    }  
}  

　　执行结果：

三、定时器线程池（定时执行线程）

使用  ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);   创建定时器线程池　

　　代码：

package demo;

import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
/** 
 * 定时器线程池 
 * 
 */  
public class ScheduledThreadPoolTest {  
    public static void main(String[] args) {  
      method1();  
//        method2();  
    }  
      
    /** 
     * 2秒之后执行线程   只执行一次
     */  
    public static void method1(){  
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);  
        //2秒之后执行这个线程  
        pool.schedule(new Runnable() {  
            @Override  
            public void run() {  
                System.out.println("爆炸");  
            }  
        }, 2, TimeUnit.SECONDS);  
    }  
      
    /** 
     * 5秒后第一次执行线程，之后每隔2秒执行一次 
     * 也就是5秒后打印第一次爆炸，之后每隔2秒打印一次爆炸 
     */  
    public static void method2(){  
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);  
        pool.scheduleAtFixedRate(new Runnable() {  
            @Override  
            public void run() {  
                System.out.println("爆炸");  
            }  
        }, 5, 2, TimeUnit.SECONDS);  
    }  
}  

　　method1执行结果：（只执行一次）

　　method2执行结果：

四、单线程池（只有一个线程的线程池）

 使用  ExecutorService pool=Executors.newSingleThreadExecutor();  创建一个单线程池

　　代码：

package demo;

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
/** 
 * 只有一个线程工作的线程池 
 * 始终保持池中有一个线程，当一个线程死了会立即重新创建一个线程 
 */  
public class SingleThreadExecutorTest {  
    public static void main(String[] args) {  
        ExecutorService pool=Executors.newSingleThreadExecutor();  
        for(int i=0;i<3;i++){  
            final int task=i;  
            pool.execute(new Runnable() {  
                @Override  
                public void run() {  
                    try {  
                        Thread.sleep(20);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                    }  
                    for(int j=0;j<3;j++){  
                        System.out.println(Thread.currentThread().getName()+"正在进行第"+(task+1)+"个任务,第"+(j+1)+"次循环");  
                    }  
                }  
            });  
        }  
    }  
}  

　　执行结果：