如何创建一个线程池

如何创建一个线程池

线程池主要使用ThreadPoolExecutor和ScheduledThreadPoolExcutor来创建

ThreadPoolExecutor

ThreadPoolExecutor一共有四个构造方法

参数介绍

参数	描述
corePoolSize	核心线程数
maximumPoolSize	最大线程数
keepAliveTime	线程存活时间
unit	时间单位
workQueue	工作队列
threadFactory	线程工厂
handler	任务拒绝策略

参数含义

corePoolSize	maximumPoolSize	keepAliveTime	unit
3	5	10	TimeUnit.SECOUNDS

当非核心线程没有任务并且达到存活时间就会被销毁

核心线程：线程池不关闭就不会被销毁

工作队列workQueue

没执行的任务都是在这里排队，线程池的线程会从这里去拿任务

线程工厂ThreadFactory

线程工厂可以执行线程如何生产线程，设置自定义线程名称，线程优先级，线程类型等

public class ThreadFActory implement THreadFactory{
    
    @Override
    Thread new THread(Runnable r){
        Thread t = new THread(r);
        t.setName("..");
        t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
    
}

任务拒绝策略handler

• 情况一：核心线程数和非核心线程数已满
• 情况二：线程池的线程都在忙碌
• 情况三：任务队列已满
• 情况四：线程池无法扩容

满足以上四种情况的时候，这个任务就会被拒绝

线程拒绝策略方式：

任务拒绝策略	描述
AbortPolicy	默认拒绝策略，抛出RejectedExecutionException异常
DiscardPolicy	直接丢弃任务
DiscardOldestPolicy	丢弃处于任务头部任务，添加被拒绝任务
CallerRunsPolicy	使用调用者线程直接执行被拒绝任务

最后，使用原生线程创建线程池代码如下:

该代码会按顺序打印出1-100

package com.javaclimb.test;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    static final int n = 1;

    public static void main(String[] args) {
        MyNumber myNumber = new MyNumber();
        Task1 task1 = new Task1(myNumber);
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 1,
                TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>(), new MyThreadFactory("task"));
        //10个任务提交给线程池
        for (int i = 1; i <= 10; i++) {
            threadPoolExecutor.execute(task1);
        }
        //关闭线程池
        threadPoolExecutor.shutdown();
    }
}

//线程工厂
class MyThreadFactory implements ThreadFactory {
    private int count = 1;
    private String prefix;

    public MyThreadFactory(String prefix) {
        this.prefix = prefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName(prefix + "-" + count++);
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
}

class MyNumber {
    public  Integer n = 1;
    public  Boolean f = false;
}

class Task implements Runnable {
    private final MyNumber myNumber;
    public Task(MyNumber myNumber) {
        this.myNumber = myNumber;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (myNumber) {
                if (myNumber.n == 100) {
                    if(!myNumber.f)System.out.println(Thread.currentThread().getName()+"->" + myNumber.n);
                    myNumber.f = true;
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"->" + myNumber.n);
                myNumber.n++;
            }
        }
    }
}

执行结果也可以看到是没问题的