Java并发线程池原理源码深入分析与调优实战

一,开篇:

        java中提供了多线程设计的Api,为什么还要用线程池呢?

        下来看两个例子:

                1.  使用多线程跑十万次

                2.  使用线程池跑十万次

使用多线程跑十万次

package com.laoyang.ThreadPool.公开课;

import java.util.ArrayList;
import java.util.Random;

/**
 * @author:Kevin
 * @create: 2023-10-25 18:27
 * @Description: 多线程跑十万次代码测试
 */

public class ThreadDemo {

    public static void main(String[] args) throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        Random random = new Random();
        ArrayList list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {

            Thread thread = new Thread() {
                @Override
                public void run() {
                    list.add(random.nextInt(10));
                }
            };
            thread.start();
            thread.join();

        }

        System.out.println("时间:" + (System.currentTimeMillis() - currentTimeMillis));
        System.out.println("大小:" + list.size());

    }
}

运行结果:

Java并发线程池原理源码深入分析与调优实战_第1张图片

使用线程池跑十万次

package com.laoyang.ThreadPool.公开课;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author:Kevin
 * @create: 2023-10-25 18:28
 * @Description: 多线程跑十万次测试
 */

public class ThraedPollDemo {
    public static void main(String[] args) throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        Random random = new Random();
        ArrayList list = new ArrayList<>();
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100000; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    list.add(random.nextInt(10));
                }
            });
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.DAYS);
        
        System.out.println("时间:" + (System.currentTimeMillis() - currentTimeMillis));
        System.out.println("大小:" + list.size());
    }
}

运行结果:

Java并发线程池原理源码深入分析与调优实战_第2张图片

        可以看出两者简直天壤地别!!!

       

        两者区别:

                1. 第一种创建了100001个线程,但是第二种只创建了两个线程

        为什么?

        创建的线程越多,是对还是错?  肯定是错的

        线程池的好处与不足?(OOM内存溢出,cpu-100%)

        底层原理?

        那为什么阿里巴巴又不推荐使用java自带的线程池呢?
       

 二,线程池

1. 初次认识常见的线程池三种方式

package com.laoyang.ThreadPool.公开课;

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

/**
 * @author:Kevin
 * @create: 2023-10-25 18:50
 * @Description: 初次认识线程池的几个构建方式
 */

public class ThreadPoolMainTest {

    public static void main(String[] args) {
        ExecutorService executorService2 = Executors.newCachedThreadPool();  //快
        ExecutorService executorService3 = Executors.newFixedThreadPool(10);  //中
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();  //慢


        for (int i = 0; i < 100; i++) {
            executorService2.execute(new Mytest(i));
        }
    }

}
class Mytest implements Runnable{

    private int i = 0;

    public Mytest(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(String.format(Thread.currentThread().getName()+ "当前开始第 %s 个项目", i));
        try {
            Thread.sleep(1000L);

        }catch (Exception e){}
    }
}

    可以发现执行速度从快到最慢

    速度: newCachedThreadPool > newFixedThreadPool > newSingleThreadExecutor

        假如将线程休眠代码注释,就会出现线程复用!

2. 剖析源码

        newCachedThreadPool点进去一个就是ThreadPoolExecutor,那么现在来深度剖析下参数的每个意思。

Java并发线程池原理源码深入分析与调优实战_第3张图片

        SynchronousQueue:同步队列(同步机制)

        可以发现只有非核心线程数,就是有一个任务,来一个非核心员工

        newFixedThreadPool点进去也是ThreadPoolExecutor

Java并发线程池原理源码深入分析与调优实战_第4张图片

        可以发现核心线程数与最大线程数的值是一样的,说明只有核心线程数,没有额外的线程数

        newSingleThreadExecutor点进去也是ThreadPoolExecutor

Java并发线程池原理源码深入分析与调优实战_第5张图片

        这个参数说明只创建了一个线程对象,个体户

       3. 自定义线程池

ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(10, 20,
                10L, TimeUnit.SECONDS, new ArrayBlockingQueue(10));

        如果自定义的话会抛出异常,会在第31个抛出异常。原因:核心线程数10,最大线程数20,所以非核心线程数将是10个,同时阻塞队列大小为10,所以当阻塞队列慢的时候就会抛出异常。

        那为什么执行的顺序为什么不一样,应该是1-10,11-20,21-30,但结果确相反?

        原理:优先级  (核心线程>非核心线程>队列线程)

你可能感兴趣的:(并发编程,java,开发语言,线程池)