Java-线程池-CSDN博客

本文链接：https://blog.csdn.net/Petrel_/article/details/107167115

在实际使用中，线程是很占用系统资源的，如果对线程管理不善很容易导致系统问题。因此，在大多数并发框架中都会使用线程池来管理线程，使用线程池管理线程主要有如下好处：
– 1、使用线程池可以重复利用已有的线程继续执行任务，避免线程在创建和销毁时造成的消耗
– 2、由于没有线程创建和销毁时的消耗，可以提高系统响应速度
– 3、通过线程可以对线程进行合理的管理，根据系统的承受能力调整可运行线程数量的大小等

线程池的工作原理

在这里插入图片描述
线程池执行所提交的任务过程：
1、先判断线程池中核心线程池所有的线程是否都在执行任务。如果不是，则新创建一个线程执行刚提交的任务，否则，核心线程池中所有的线程都在执行任务，则进入第2步；
2、判断当前阻塞队列是否已满，如果未满，则将提交的任务放置在阻塞队列中；否则，则进入第3步；
3、判断线程池中所有的线程是否都在执行任务，如果没有，则创建一个新的线程来执行任务，否则，则交给饱和策略进行处理

线程池的分类

在这里插入图片描述

线程池的生命周期

在这里插入图片描述
RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务；
SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。
STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。
TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。
TERMINATED：在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做。

线程池的创建

在这里插入图片描述
corePoolSize：核心线程池的大小
maximumPoolSize：线程池能创建线程的最大个数
keepAliveTime：空闲线程存活时间
unit：时间单位，为keepAliveTime指定时间单位
workQueue：阻塞队列，用于保存任务的阻塞队列
threadFactory：创建线程的工程类
handler：饱和策略（拒绝策略）

execute方法执行逻辑

如果当前运行的线程少于corePoolSize，则会创建新的线程来执行新的任务；
如果运行的线程个数等于或者大于corePoolSize，则会将提交的任务存放到阻塞队列workQueue中；
如果当前workQueue队列已满的话，则会创建新的线程来执行任务；
如果线程个数已经超过了maximumPoolSize，则会使用饱和策略RejectedExecutionHandler来进行处理。

线程池的关闭

关闭线程池，可以通过shutdown和shutdownNow两个方法
原理：遍历线程池中的所有线程，然后依次中断
1、shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程，并返回等待执行任务的列表；
2、shutdown只是将线程池的状态设置为SHUTDOWN状态，然后中断所有没有正在执行任务的线程

CacheThreadPool

package com.petrel.demo.demo;

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

/**
 * @author Petrel
 * @data 2020/6/29 20:26
 */
//线程池触发线程 一起执行
public class CacheThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

------------

package com.petrel.demo.demo;

/**
 * @author Petrel
 * @data 2020/6/29 20:29
 */

public class Task implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000); //不加这句话CacheThreadPoolDemo运行会出现重复线程 复用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"running");
    }
}

FixedThreadPool

package com.petrel.demo.demo;

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

/**
 * @author Petrel
 * @data 2020/6/29 20:39
 */
//规定几个一起执行
public class FixedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5); //5个线程5个线程执行
        for (int i = 0;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

SingleThreadPoolDemo

package com.petrel.demo.demo;

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

/**
 * @author Petrel
 * @data 2020/6/29 20:54
 */
//一个一个执行
public class SingleThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0;i<20;i++){
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

ScheduledThreadPool

package com.petrel.demo.demo;

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

/**
 * @author Petrel
 * @data 2020/6/30 9:43
 */
//延迟
//延迟三秒执行：schedule()方法
public class ScheduledThreadPoolDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        System.out.println(System.currentTimeMillis());//运行结果：1593481712713
        scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟三秒执行");
                System.out.println(System.currentTimeMillis());//运行结果：1593481715722
            }
        },3, TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();

    }
}
/*
1593481715722-1593481712713≈3000 3秒
 */

package com.petrel.demo.demo;

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

/**
 * @author Petrel
 * @data 2020/6/30 9:43
 */
//定时
//每三秒执行一次：scheduleAtFixedRate()方法
public class ScheduledThreadPoolDemo2 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        System.out.println(System.currentTimeMillis());//运行结果：1593481712713
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟一秒执行，每三秒执行一次");
                System.out.println(System.currentTimeMillis());//运行结果：1593481715722
            }
        },1,3, TimeUnit.SECONDS);
        //scheduledExecutorService.shutdown();

    }
}
/*
运行结果：
        1593482149884
        延迟一秒执行，每三秒执行一次
        1593482150894
        延迟一秒执行，每三秒执行一次
        1593482153897
        延迟一秒执行，每三秒执行一次
        1593482156897
        延迟一秒执行，每三秒执行一次
        1593482159893
        延迟一秒执行，每三秒执行一次
        1593482162930
        延迟一秒执行，每三秒执行一次
        ......
 */

ExecutorService

package com.petrel.demo.callable;

import java.util.concurrent.Callable;

/**
 * @author Petrel
 * @data 2020/6/30 17:15
 */

public class Task implements Callable<String> {

    private int i;

    public Task(int i){
        this.i = i;
    }
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        return Thread.currentThread().getName()+"is running"+i;
    }
}

------------

package com.petrel.demo.callable;

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

/**
 * @author Petrel
 * @data 2020/6/30 17:15
 */

public class Test {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0;i<20;i++){
            Future<String> submit = executorService.submit(new Task(i));
            try {
                String str = submit.get();
                System.out.println(str);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
运行结果：
        pool-1-thread-1is running0
        pool-1-thread-2is running1
        pool-1-thread-3is running2
        pool-1-thread-4is running3
        pool-1-thread-5is running4
        pool-1-thread-1is running5
        pool-1-thread-2is running6
        pool-1-thread-3is running7
        pool-1-thread-4is running8
        pool-1-thread-5is running9
        pool-1-thread-1is running10
        pool-1-thread-2is running11
        pool-1-thread-3is running12
        pool-1-thread-4is running13
        pool-1-thread-5is running14
        pool-1-thread-1is running15
        pool-1-thread-2is running16
        pool-1-thread-3is running17
        pool-1-thread-4is running18
        pool-1-thread-5is running19
 */

ThreadPool

package com.petrel.demo;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author Petrel
 * @data 2020/6/30 17:34
 */

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,new ArrayBlockingQueue(5));
        threadPoolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Math.random());//运行结果：0.6386970527063673
            }
        });
    }
}