Java使用线程池创建线程

一、线程前言

        首先我们知道，线程的概念如果不知道可以去看这一篇Java中的线程，我们这篇主要讲述的是Java怎么使用线程池创建线程，首先我们要对线程池有点概念，其实顾名思义，线程池就是有喝多线程的一个池子类似于，大家搞数据库连接的时候的数据库连接池druid，什么池那就是存的什么东西了。

二、普通线程使用

        我们回忆一下最基本的线程创建，是不是继承Thread或者是实现Runnable接口 ，我们基本上都选用的是实现Runnable接口，因为Java是单继承，指不定我们又要继承其他什么东西呢。

Thread类

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); 
    }
}
 
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running.");
    }
}

我们通过重写run方法进行线程运行的内容的编写。

Runnable接口

都已经学习线程池了，所以大家肯定都是会lambda表达式的吧，我们直接写lambda表达式。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(()-> System.out.println("The lambda Runnable interface implements"));
        thread.start();
    }
}

这就是最基本的线程创建以及启动，相信大家都很熟悉了。接下来我们来看看高级一点的，线程池的使用。

三、使用线程池

Executors类

这个类在JUC里面，juc也就是java.util.concurrent。是Java处理多线程的一个工具类，假如你以后想要有更高的上升渠道，你是必须要学的。废话不多说，我们上代码。

package thread;

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

public class Main {
    public static void main(String[] args) {
        // 创建线程池对象，我们这里设置了2个为上限，所以线程池内的线程的上限就是2
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // 给线程池对象分配任务，每一个任务是一个线程
        pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 1));

        pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 2));

        pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 3));

        pool.shutdown();
    }
}

如果你用的IDEA的版本比较新你可能会看到他提示你。

没有关系，我们使用一下try-with-resources的方式来运行一下，这次我们把上限继续调成3个。

package thread;

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

public class Main {
    public static void main(String[] args) {
        // 创建线程池对象，我们这里设置了3个为上限
        try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
            // 给线程池对象分配任务，每一个任务是一个线程
            pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 1));

            pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 2));

            pool.execute(() -> System.out.println(Thread.currentThread().getName() + " " + 3));
            // 因为使用了try-with-resources的方式，所以我们不需要手动关闭我们的线程池了，他会自动关闭的。就和IO流一样
//            pool.shutdown();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
}

然后我们也能看到我们的线程也是出现了3的字眼。

但是我们留意一下阿里的开发手册我们会发现。

所以我们要使用接下来的一个线程池的方式去创建线程。

ThreadPoolExecutor

但是我们用ThreadPoolExecutor去创建线程池的话，因为是自定义线程池，所以可选的东西很多，所以得仔细看了，我们直接选用最少参数的构造器。

package thread;

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

public class Main {
    public static void main(String[] args) {
        /*
            第一个参数是核心池大小，也就是用几个核心去处理
            第二个参数是最大线程数量
            第三个参数则是存活时间
            第四个参数则是第三个参数的单位是什么
            第五个参数则是存放线程的队列是什么，我这里选择的事LinkedBlockingQueue
         */
        try (ThreadPoolExecutor pool = new ThreadPoolExecutor(
                4,
                8,
                60,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>())) {
            for (int i = 0; i < 10; i++) {
                pool.execute(() -> System.out.println(Thread.currentThread().getName()));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
}

pool-1-thread-1
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-3
pool-1-thread-2
pool-1-thread-2
pool-1-thread-1
pool-1-thread-4
pool-1-thread-3

进程已结束，退出代码为 0

这就是线程池的两个基本用法，我们明显可以从打印信息看出来，他的名字是pool开始。

如果对你有帮助，你能学习到东西请帮我点个赞点个收藏。