JAVA常用线程池

CacheThreadPool

创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。缓存型池子通常用于执行一些生存期很短的异步型任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 public class ThreadPoolExecutorTest {
     public static void main(String[] args) {
         //创建一个可缓存线程池
         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
         for (int i = 0; i < 10; i++) {
              
             cachedThreadPool.execute(new Runnable() {
                 public void run() {
                     //打印正在执行的缓存线程信息
                     System.out.println(Thread.currentThread().getName()+"正在被执行");
                 }
             });
         } 
        cachedThreadPool.shutdown();
     }
 }

 

结果分析：每次开启的线程数量不等，根据任务完成情况来判断是否需要创建新的线程。

FixedThreadPool(int n)

创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。

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

public class ThreadPoolExecutorTest {
	public static void main(String[] args) {
		// 创建一个可重用固定个数的线程池
		 
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			fixedThreadPool.execute(new Runnable() {
				public void run() {
					try {
						// 打印正在执行的缓存线程信息
						System.out.println(Thread.currentThread().getName() + "正在被执行");
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
        fixedThreadPool.shutdown();
	}
}

 

ScheduledThreadPool(int n)

创建一个定长线程池，支持定时及周期性任务执行

延迟执行示例代码：

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("延迟1秒执行");
            }
        }, 1, TimeUnit.SECONDS);
        scheduledThreadPool.shutdown();
    }
}

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

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——定期执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
       scheduledThreadPool.shutdown();
    }
}

SingleThreadExecutor()

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

 

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                //结果依次输出，相当于顺序执行各个任务
        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                }
            });
        }
        singleThreadExecutor.shutdown();
    }
}

 

Callable 和 Future接口的区别

  （1）Callable规定的方法是call()，而Runnable规定的方法是run(). 

  （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。  

  （3）call()方法可抛出异常，而run()方法是不能抛出异常的。 

  （4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 

它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。 

通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。 

Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolWithcallable {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService pool = Executors.newFixedThreadPool(4);
		for(int i=0;i<10;i++) {
			 
			Future<String> submit =pool.submit( new Callable<String>() {
				@Override
				public String call() throws Exception {
					Thread.sleep(1000);
					return "b--"+Thread.currentThread();
				}
			});
			 //线程没有完成前不会得到信息。
			System.out.println(submit.get());
		}
		pool.shutdown();
	}
}

WorkStealingPool

任务窃取线程池，不保证执行顺序，适合任务耗时差异较大。

线程池中有多个线程队列，有的线程队列中有大量的比较耗时的任务堆积，而有的线程队列却是空的，就存在有的线程处于饥饿状态，当一个线程处于饥饿状态时，它就会去其它的线程队列中窃取任务。解决饥饿导致的效率问题。默认创建的并行 level 是 CPU 的核数。主线程结束，即使线程池有任务也会立即停止。