线程池详解

线程池详解

1、newCacheThreadPool

该线程池被成为缓存线程池，缓存线程池通常用来执行一些异步的且生命周期较短的任务，执行逻辑：如果池中有线程则拿来直接用，如果没有，则创建一个线程，如果执行当前任务发现上一个任务已经被执行完毕，则直接把执行上一个任务的线程拿来服用

package com.StrBuilderTest;

import sun.awt.windows.ThemeReader;

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

public class StrDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i=0;i<=10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"正在执行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
        executorService.shutdown();

    }

}

2、newFixedThreadPool

该线程池生成固定个数的复用线程，如果任务多，复用线程少，那么就会出现阻塞状态

package com.StrBuilderTest;

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

public class ThreadPool {


    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i=0;i<10;i++){
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"正在被执行");
                }
            });
        }
        executorService.shutdown();
    }
}

3、newScheduledThreadPool

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

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

public class NewScheduledThreadPoolTest {

    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);

    }

}

4、newSingleThreadPool

该线程池中只有一个处于工作的线程，也就是核心线程，该线程池中的核心线程会根据任务顺序执行

package com.StrBuilderTest;

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

public class singleThreadPool {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for(int i=0;i<=10;i++){
            final  int k=i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("正在执行，当前输出"+k);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        executorService.shutdown();
    }
}