常见的6种线程池及简单使用

jdk8线程池一共有6种，分别是

CachedThreadPool(cached线程池，当有任务进来的时候如果有空闲的线程则直接利用，如果无空闲线程，则新创建一个线程出来使用),
ScheduleThreadPool（schedule线程池，定时线程池，指定一个线程什么时候开始执行）,
SingleThreadPool（single单例线程池，保只有一个线程，保证数据先后执行的顺序一致）,
ForkJoinThreadPool（forkjoin分割，合并线程池，当进行大量的数据统计运算时，将大量的数据分割成许许多多的小任务，最后汇总任务的处理结果，提高效率）,
fixedThreadPool（fixed固定数量的线程池，创建固定数量的线程，任务进来时候哪个有空哪个窒息ing）,
WorkStealingThreadPool（workstealing，每个线程都监听自己的队列，当自己的队列中任务执行均完成后拉取其他队列的任务进行执行）

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
 * 线程池学习  executorservice
 * fixed线程池
 * @author liuhao
 *
 */
public class ThreadPoolExecteServiceLearn {
public static void main(String[] args) throws InterruptedException {
	ExecutorService executorService = Executors.newFixedThreadPool(5);//定义一个线程池
	for(int i = 0 ; i < 6; i ++) {
		executorService.execute(()->{
			try {
				TimeUnit.MILLISECONDS.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		});
		//俩种放入方式，第一种只能放runnable,第二种可以让runnable和collable（又返回值）executorService.submit(()->{});
	}
	executorService.shutdown();
	System.out.println(executorService);//线程池详细属性
	System.out.println(executorService.isTerminated());//所有任务是否均执行
	System.out.println(executorService.isShutdown());//是否停止线程池
	
	TimeUnit.SECONDS.sleep(5);
	
	System.out.println(executorService.isTerminated());
	System.out.println(executorService.isShutdown());//停止线程池
	System.out.println(executorService);//线程池详细属性
}
}

package learn.thread0304;

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

/**
 * cach线程池
 * @author liuhao
 *
 */
public class ThreadPoolCachLearn {
public static void main(String[] args) throws InterruptedException {
	ExecutorService executorService = Executors.newCachedThreadPool();//缓存线程池，有仍无进来，new，有空的
	System.out.println(executorService);
		for(int i =  0; i < 5 ; i++ ) {

			executorService.execute(()->{
				try {
					TimeUnit.SECONDS.sleep(3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName());
			});
		}
		System.out.println(executorService);
		TimeUnit.SECONDS.sleep(10);
		System.out.println(executorService);
		for(int i = 0;i<3;i++) {
			executorService.execute(()->{
				try {
					TimeUnit.SECONDS.sleep(3);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			});
		}
		TimeUnit.SECONDS.sleep(1);
		System.out.println(executorService.isTerminated());
		System.out.println(executorService);
		executorService.shutdown();
}
}

package learn.thread0304;

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

/**
 * 定时线程池
 * @author liuhao
 *
 */
public class ThreadPoolScheduleLearn {
public static void main(String[] args) {
	ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);
	/*
	scheduledExecutorService.scheduleAtFixedRate(()->{
		try {
			TimeUnit.SECONDS.sleep(new Random().nextInt(10));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//定时执行的方法
		System.out.println("线程名"+Thread.currentThread().getName());
	}, 0, 500, TimeUnit.MILLISECONDS);//指定规则执行
	*/
	scheduledExecutorService.scheduleWithFixedDelay(()->{
		try {
			TimeUnit.MICROSECONDS.sleep(1000);
			System.out.println("///"+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}, 0, 1, TimeUnit.SECONDS);//前一个线程结束多久之后执行
	
}
}

package learn.thread0304;

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

/**
 * 单例模式执行 ，保证任务顺序执行
 * @author liuhao
 *
 */
public class ThreadPoolSingleLearn {
public static void main(String[] args) {
	ExecutorService executorService = Executors.newSingleThreadExecutor();
	for(int i =0;i<5 ;i++) {
		final int j = i ;
		executorService.execute(()->{
			System.out.println(j+"///"+Thread.currentThread().getName());
		});
	}
}
}

package learn.thread0304;

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * workstealingpool//工作窃取线程池
 * 
 * 每个线程监听自己的队列，当当前队列任务执行均结束，则去别的队列拉取任务执行
 * 
 * @author liuhao
 *
 */
public class ThreadPoolWorkStealingPool {
	public static void main(String[] args) throws IOException, InterruptedException {
		ExecutorService executorService = Executors.newWorkStealingPool(3);
		System.out.println(Runtime.getRuntime().availableProcessors());
		executorService.execute(new AddTask(100));// 精灵线程，后台线程，daemon，主线程不阻塞看不到输出
		executorService.execute(new AddTask(200));
		executorService.execute(new AddTask(300));
		executorService.execute(new AddTask(400));
		executorService.execute(new AddTask(500));
		executorService.execute(new AddTask(600));
		System.out.println(executorService);
		TimeUnit.MICROSECONDS.sleep(6000);
		System.out.println(executorService);
		System.in.read();
	}

	static class AddTask implements Runnable {
		long time;

		public AddTask(long time) {
			super();
			this.time = time;
		}

		@Override
		public void run() {
			try {
				TimeUnit.MICROSECONDS.sleep(time);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(time+"///123" + Thread.currentThread().getName());
		}

	}
}

package learn.thread0304;

import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

/**
 * forkjoin 将一个项目分成多个子项目，提高效率

 * 使用过时需要注意，RecursiveAction接口无返回值，RecursiveTask有返回值，使用join求和
 *
 * @author liuhao
 */
public class ForkJoinPoolLearn {
    static Random random = new Random();
    static final int MAX_VAL = 50000;
    static int[] nums = new int[1000000];

    /**
     * 线程运行求取数组的和
     */
    //方法一，数组便利求和
    static {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(100);
        }
        System.out.println("数组值为" + Arrays.stream(nums).sum());

    }

    //方法二forkjoin
/*	static class AddTask extends RecursiveAction{
		private static final long serialVersionUID = 1L;
		int start ,end;

		public AddTask(int start, int end) {
			super();
			this.start = start;
			this.end = end;
		}

		@Override
		protected void compute() {
			if(end-start < MAX_VAL) {
				long sum = 0l;
				for(int i = start ; i < end; i ++) {
					sum = sum + nums[i];
				}
				System.out.println(sum);
			}else {
				int middle = start + (end - start)/2;
				AddTask AddTask01 = new AddTask(start,middle);
				AddTask AddTask02 = new AddTask(middle,end);
				AddTask01.fork();
				AddTask02.fork();
			
			}
		}
		
	}*/
    //方法三，RecursiveTask,又返回值
    static class AddTask extends RecursiveTask<Long> {
        private static final long serialVersionUID = 1L;
        int start, end;

        public AddTask(int start, int end) {
            super();
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {
            if (end - start < MAX_VAL) {
                long sum = 0l;
                for (int i = start; i < end; i++) {
                    sum = sum + nums[i];
                }
                //System.out.println(sum);
                return sum;
            } else {
                int middle = start + (end - start) / 2;
                AddTask AddTask01 = new AddTask(start, middle);
                AddTask AddTask02 = new AddTask(middle, end);
                AddTask01.fork();
                AddTask02.fork();
                return AddTask01.join() + AddTask02.join();

            }
        }

    }

    public static void main(String[] args) throws IOException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        AddTask task = new AddTask(0, nums.length);
        forkJoinPool.execute(task);
        long result = task.join();
        System.out.println(result);
        System.in.read();
    }

    ;
}