JUC - 线程池

于 2023-03-28 15:28:36 发布
阅读量149 收藏
点赞数 1
分类专栏： juc 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44740736/article/details/129434449
版权

1 自定义线程池

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
public class Demo {

    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(2, 3, 5, TimeUnit.SECONDS, (task, queue) -> {
            // 1 死等
//            queue.put(task);
            // 2 超时等
//            queue.put(task, 1, TimeUnit.SECONDS);
            // 3 抛出异常
//            throw new RuntimeException("任务超出阻塞队列数");
            // 4 自己执行
            task.run();
            // 5 放弃执行 什么都不做

        });
        for (int i = 0; i < 10; i++) {
            int j = i;
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "开始执行 任务" + j);
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "结束执行 任务" + j);
            });
        }

    }
}

/**
 * 拒绝策略
 */
@FunctionalInterface
interface RejectPolicy<T> {
    void reject(T task, BlockedQueue<T> queue);
}

/**
 * 线程池
 */
@Slf4j(topic = "ThreadPool")
class ThreadPool {

    /**
     * 核心线程数
     */
    private final int coreSize;

    /**
     * 线程集合
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();

    /**
     * 阻塞队列
     */
    private final BlockedQueue<Runnable> blockedQueue;

    /**
     * 线程超时时间
     */
    private final long timeout;

    /**
     * 拒绝策略
     */
    private RejectPolicy<Runnable> rejectPolicy;

    /**
     * 超时时间单位
     */
    private final TimeUnit timeUnit;

    public ThreadPool(int coreSize, int queueCapacity, int timeout, TimeUnit timeUnit, RejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.blockedQueue = new BlockedQueue<>(queueCapacity);
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.rejectPolicy = rejectPolicy;
    }

    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(Runnable task) {
        synchronized (this) {
            if (workers.size() < coreSize) {
                Worker worker = new Worker(task);
                workers.add(worker);
                worker.start();
            } else {
                blockedQueue.put(task, rejectPolicy);
            }
        }


    }

    class Worker extends Thread {
        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            while (task != null || (task = blockedQueue.take(timeout, timeUnit)) != null) {
                try {
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }

            workers.remove(this);
        }
    }
}

/**
 * 阻塞队列
 * 平衡线程与任务的中间件
 *
 * @param <T>
 */
@Slf4j(topic = "BlockedQueue")
class BlockedQueue<T> {

    /**
     * 任务队列
     */
    private final Deque<T> queue = new ArrayDeque<>();

    /**
     * 队列的容量
     */
    private final int capacity;

    /**
     * 锁
     */
    private final ReentrantLock lock = new ReentrantLock();

    /**
     * 队列满了 任务到这等待
     */
    private final Condition fullQueue = lock.newCondition();

    /**
     * 队列为空 线程到这等待
     */
    private final Condition emptyQueue = lock.newCondition();

    public BlockedQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 获取任务
     */
    public T take() {
        // 添加锁 避免两个线程同时获取同一个任务
        lock.lock();
        try {
            // 任务队列为空
            while (queue.isEmpty()) {
                try {
                    // 当前线程获取不到任务进入等待
                    System.out.println(Thread.currentThread().getName() + " 等待");
                    emptyQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 获取队列第一个任务
            System.out.println(Thread.currentThread().getName() + " 获取任务");
            T t = queue.removeFirst();
            // 唤醒一个没有添加进任务队列而等待的任务
            fullQueue.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }


    /**
     * 超时获取任务
     *
     * @param timeout  时间
     * @param timeUnit 时间单位
     */
    public T take(long timeout, TimeUnit timeUnit) {

        timeout = timeUnit.toNanos(timeout);
        // 添加锁 避免两个线程同时获取同一个任务
        lock.lock();
        try {
            // 任务队列为空
            while (queue.isEmpty()) {
                try {
                    // 等待时间到期 返回空 规定时间内未获得任务
                    if (timeout <= 0) {
                        return null;
                    }
                    // 当前线程获取不到任务进入等待 next 返回的是剩余时间
                    System.out.println(Thread.currentThread().getName() + " 线程等待");
                    timeout = emptyQueue.awaitNanos(timeout);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 获取队列第一个任务
            System.out.println(Thread.currentThread().getName() + " 获取任务");
            T t = queue.removeFirst();
            // 唤醒一个没有添加进任务队列而等待的任务
            fullQueue.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务到队列
     *
     * @param t 任务
     */
    public void put(T t) {

        // 添加锁 避免两个线程同时添加同一个任务
        lock.lock();
        try {
            // 任务队列打到最大容量
            while (queue.size() == capacity) {
                try {
                    // 不能添加任务进入等待
                    System.out.println(Thread.currentThread().getName() + " 任务等待");
                    fullQueue.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 向队列末尾添加任务
            System.out.println(Thread.currentThread().getName() + " 添加任务");
            queue.addLast(t);
            // 唤醒 没有获取任务的线程
            emptyQueue.signal();
        } finally {
            lock.unlock();
        }
    }


    /**
     * 添加任务到队列
     *
     * @param t 任务
     * @param timeout 超出时间
     * @param timeUnit 超出时间单位
     */
    public void put(T t, long timeout, TimeUnit timeUnit) {
        timeout = timeUnit.toNanos(timeout);
        // 添加锁 避免两个线程同时添加同一个任务
        lock.lock();
        try {
            // 任务队列打到最大容量
            while (queue.size() == capacity) {
                try {
                    if (timeout <= 0) {
                        throw new RuntimeException("添加任务超出时间");
                    }
                    // 不能添加任务进入等待
                    System.out.println(Thread.currentThread().getName() + " 任务超时等待");
                    timeout = fullQueue.awaitNanos(timeout);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 向队列末尾添加任务
            System.out.println(Thread.currentThread().getName() + " 添加任务");
            queue.addLast(t);
            // 唤醒 没有获取任务的线程
            emptyQueue.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务到队列
     *
     * @param t            任务
     * @param rejectPolicy 拒绝策略
     */
    public void put(T t, RejectPolicy<T> rejectPolicy) {
        // 添加锁 避免两个线程同时添加同一个任务
        lock.lock();
        try {
            // 任务队列打到最大容量
            if (queue.size() == capacity) {
                // 执行拒绝策略
                System.out.println(Thread.currentThread().getName() + " 执行拒绝策略");
                rejectPolicy.reject(t, this);
            } else {
                // 向队列末尾添加任务
                System.out.println(Thread.currentThread().getName() + " 添加任务");
                queue.addLast(t);
                // 唤醒 没有获取任务的线程
                emptyQueue.signal();
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取队列长度
     */
    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }
}

2 ThreadPoolExecutor

在这里插入图片描述

2.1 线程池状态

ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量

状态名高 3 位接收新任务处理阻塞队列任务说明
RUNNING111YY
SHUTDOWN000NY不会接收新任务，但会处理阻塞队列剩余任务
STOP001NN会中断正在执行的任务，并抛弃阻塞队列任务
TIDYING010--任务全执行完毕，活动线程为0即将进入终结
TERMINATED011--终结状态

从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING

这些信息存储在一个原子变量 ctl 中，目的是线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值

// c 为旧值， ctlOf 返回结果为新值
ctl.comareAndSet(c, ctlOf(targetState, workerCountOf(c)));

// rs 为高 3 位代表线程池状态，wc 低 29 位代表线程个数，ctl 是合并它们
private static int ctlOf(int rs, int wc) { return rs | wc; }

2.2 构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {...}
  • corePoolSize 核心线程数目 （最多保留的线程数）
  • maximumPoolSize 最大线程数目
  • keepAliveTime 生存时间 - 针对救急线程
  • unit 时间单位 - 针对救急线程
  • workQueue 阻塞队列
  • threadFactory 线程工厂 - 可以为线程创建时起个好名字
  • handler 拒绝策略
  • 线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务
  • 当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入 workQueue 队列排队，知道有空闲的线程。
  • 如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线程来救急。
  • 如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 种实现，其它著名框架也提供了实现
    • AbortPolicy 让调用者抛出 RejectedExceutionException 异常，这是默认策略
    • CallerRunsPolicy 让调用者运行任务
    • DiscardPolicy 放弃本次任务
    • DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之
    • Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程信息，方本定位问题
    • Netty 的实现，是创建一个新县城来执行任务
    • ActiveMQ 的实现，带超时等待 （60s）尝试放入队列，类似我们之前自定义的拒绝策略
    • PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链子中每种拒绝策略
  • 当高峰过后，超过 corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由 keepAliveTime 和 unit 来控制。

在这里插入图片描述

2.3 newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

特点

  • 核心线程数 – 最大线程数 （没有救急线程被创建）因此也无需超时时间
  • 阻塞队列是无界的，可以放任意数量的任务

2.4 newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

特点

  • 核心线程是 0，最大线程数是Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着
    • 全部都是救急线程（60s后可以回收）
    • 救急线程可以无限创建
  • 队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱，一手交货）

2.5 newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

使用场景：

希望多个任务排队执行。线程数固定为 1，任务数1多于 1 时，会放入无界队列排队。任务执行完毕，着唯一的线程也不会被释放。

区别

  • 自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作
  • Executors.newSingleThreadExecutor() 线程个数始终为 1，不能修改
  • Executors.newFixedThreadPool(1) 初始值为1，以后还可以修改

2.6 submit

提交任务 task，用返回值 Future 获得任务执行结果

<T> Future<T> submit(Callable<T> task);

2.7 invokeAll

提交 tasks 中所有任务，带超时时间

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;

2.8 invokeAny

提交 tasks 中所有任务，哪个任务先执行完毕，返回此任务执行结果，其它任务取消

<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

2.9 shutdown

线程池状态变为 SHUTDOWN

  • 不会接收新任务
  • 但已提交任务会执行完
  • 此方法不会阻塞调用线程的执行
void shutdown();

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改线程池状态
        advanceRunState(SHUTDOWN);
        // 仅会打断空闲线程
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    // 尝试终结（没有运行的线程可以立刻终结的）
    tryTerminate();
}

2.10 shutdownNow

线程池状态变为 STOP

  • 不会接收新任务
  • 会将队列中的任务返回
  • 并用 interrupt 的方式中断正在执行的任务
void shutdown();

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

3 创建线程

3.1 CPU 密集型运算

通常采用 cpu 核数+1能够实现最优的 CPU利用率，+1 是保当线程由于页缺失故障(操作系统)或其它原因导致暂停时，额外的这个线程就能顶上去，保证CPU 时钟周期不被浪费

3.2 I/O 密集型运算

CPU 不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用CPU资源，但当你执行 IO 操作时或者远程RPC 调用时，包括进行数据库操作时，这时候 CPU 就闲下来了，你可以利用多线程提高它的利用率

经验公式如下

线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间等待时间) / CPU 计算时间例如4核CPU计算

时间是50%，其它等待时间是 50%，期望 cpu 被 100%利用，套用公式

4 * 100% * 100% / 50% = 8

例如4核CPU计算时间是10%，其它等待时间是90%，期望 cpu 被 100%利用，套用公式

4 * 100% * 100% / 10% = 40

4 定时任务

4.1 Timer

  • 串行化
  • 前面任务影响后续任务
        Timer timer = new Timer();
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis());
            }
        };

        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis());
            }
        };

        timer.schedule(task1, 1000);
        timer.schedule(task2, 2000);

4.2 ScheduledExecutorService

延迟执行

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
service.schedule(() -> {
    System.out.println(11111);
}, 1, TimeUnit.SECONDS);

定时执行

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

service.scheduleAtFixedRate(() -> {
    System.out.println(1);
}, 1, 1, TimeUnit.SECONDS);

5 处理线程异常

callable会抛出异常

ExecutorService service = Executors.newFixedThreadPool(5);
Future<Integer> future = service.submit(() -> {
    int i = 1 / 0;
    return i;
});

System.out.println(future.get());

6 Fork/Join

Fork/Join是JDK1.7加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算

所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。跟递归相关的一些计算，如归并排序、斐波那契数列、都可以用分治思想进行求解

Fork/Join 在分治的基础上加入了多线程，可以把每个任务的分解和合并交给不同的线程来完成，进一步提升了运算效率

Fork/Join 默认会创建与 cpu 核心数大小相同的线程池

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值