文章目录

• Java 多线程和线程池使用
• • java多线程实现的几种方法
  • • 1.继承Thread类
    • 2.实现Runnable接口
    • 3.实现Callable接口
  • Java线程池的使用
  • • 线程池的优点
    • Java线程池
    • • Executor接口继承关系
      • ThreadPoolExecutor构造方法参数详解
  • 线程和线程池的使用规范

Java 多线程和线程池使用

java多线程实现的几种方法

1.继承Thread类

继承Thread类，重写run方法，创建线程类对象调用start方法启动线程。

public class ThreadDemo {        public static class MyThread extends Thread {        public MyThread() {        }        public MyThread(String threadName) {            this.setName(threadName);        }        @Override        public void run() {            for (int i = 0; i < 10; i++) {                System.out.println("继承Thread类创建线程:" + this.getName() + " " + i);            }        }    }    public static void main(String[] args) {        MyThread myThread1 = new MyThread("thread1");        MyThread myThread2 = new MyThread("thread2");        MyThread myThread3 = new MyThread("thread3");        myThread1.start();        myThread2.start();        myThread3.start();    }}

程序三次运行结果如下图（部分）：

2.实现Runnable接口

Runnable接口中只有一个抽象run方法。

实现Runnable接口重写run方法创建自己的线程，调用start方法启动线程。

public class ThreadDemo {        public static class MyRunnable implements Runnable {        @Override        public void run() {            for (int i = 0; i < 10; i++) {                System.out.println("实现Runnable创建线程:" + Thread.currentThread().getName() + " " + i);            }        }    }    public static void main(String[] args) {        MyRunnable myRunnable = new MyRunnable();        Thread thread1 = new Thread(myRunnable);        Thread thread2 = new Thread(myRunnable);        Thread thread3 = new Thread(myRunnable);        thread1.setName("thread1");        thread2.setName("thread2");        thread3.setName("thread3");        thread1.start();        thread2.start();        thread3.start();    }}

利用构造函数Thread(Runnable target) 启动线程，实际上Thread类也实现了Runnable接口，这样就可以将Thread对象交由其他线程调用run方法执行。

3.实现Callable接口

Runnable是出自jdk1.0，Callable出自jdk1.5，Callable相当于是对Runnable接口的增强，Runnable和Callable接口的区别就在于Callable接口有一个带有返回值的call方法，并且可以抛出异常。

public class ThreadDemo {        public static class MyCallable implements Callable {        @Override        public String call() throws Exception {            for (int i = 0; i < 10; i++) {                System.out.println("实现Callable创建线程:" + Thread.currentThread().getName() + " " + i);            }            return "线程执行完成";        }    }    public static void main(String[] args) throws ExecutionException, InterruptedException {        FutureTask futureTask = new FutureTask<>(new MyCallable());        Thread thread = new Thread(futureTask);        long start = System.currentTimeMillis();        thread.start();        String result = futureTask.get();        System.out.printf("线程执行结果【%s】,耗时：%d ms", result, System.currentTimeMillis() - start);    }}

实现Callable接口，重写call方法，通过FutureTask交给线程执行，阻塞等待结果返回。

callable逻辑交由异步线程处理，主线程通过阻塞接受异步线程返回内容。

以下是根据JAVA FutureTask类源码注释翻译的内容：

FutureTask:一个可取消的异步的计算，这个类实现了runnable和Future接口。future提供了开始，取消计算，查询计算是否完成。get()方法将会是堵塞的，调用get()方法将会堵塞直到计算完成返回结果。一旦计算完成了就不可以再次开始或者取消，除非是调用runAndReset()方法。

FutureTask有NEW,COMPLETING,NORMAL,EXCEPTIONAL,CANCELLED,INTERRUPTING和INTERRUPTED七种状态，创建时状态为NEW，结果未赋值时更新为COMPLETING，结果赋值后更新为NORMAL，发生异常后会将状态置为EXCEPTIONAL，调用cancel方法后更新为CANCELLED或者INTERRUPTING状态。

Java线程池的使用

线程池的优点

1. 线程池能够最大化资源的利用率，因为它可以重复利用已经创建的线程，避免了每次创建和销毁线程时的开销。

2. 线程池可以根据需要动态地创建和销毁线程，从而更好地管理和调度线程，提高程序的性能和响应速度。

3. 线程池可以更有效地处理大量并发请求，因为它可以将任务拆分成较小的部分，并发地提交给线程池中的线程处理，从而更快地完成任务。

4. 线程池可以减少锁竞争等线程间相互干扰的问题，提高了程序的正确性和可靠性。

5. 线程池可以提高程序的安全性，因为它可以限制同一时间只有一个线程可以执行某个任务，减少了多个线程同时执行同一个任务时可能发生的错误。

池化技术基本都具有提高程序的性能、响应速度、资源利用率、方便统一管理的优点

Java线程池

ThreadPoolExecutor 线程池位于 java.util.concurrent 包下,是 Java 中用于实现线程池的一种基础类。

Executor接口继承关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-34Xh6Btu-1683707829709)(file:///home/physicx/.config/marktext/images/2023-05-10-14-43-13-image.png?msec=1683700993670)]

• Executor线程池相关顶级接口，它将任务的提交与任务的执行分离开来。

• ExecutorService继承并扩展了Executor接口，提供了Runnable、FutureTask等主要线程实现接口扩展。

• ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。

• ScheduledExecutorService接口，是延时执行类任务的主要实现。

ThreadPoolExecutor构造方法参数详解

以下是ThreadPoolExecutor包含所有参数的构造方法：

public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue workQueue,                              ThreadFactory threadFactory,                              RejectedExecutionHandler handler) {        if (corePoolSize < 0 ||            maximumPoolSize <= 0 ||            maximumPoolSize < corePoolSize ||            keepAliveTime < 0)            throw new IllegalArgumentException();        if (workQueue == null || threadFactory == null || handler == null)            throw new NullPointerException();        this.acc = System.getSecurityManager() == null ?                null :                AccessController.getContext();        this.corePoolSize = corePoolSize;        this.maximumPoolSize = maximumPoolSize;        this.workQueue = workQueue;        this.keepAliveTime = unit.toNanos(keepAliveTime);        this.threadFactory = threadFactory;        this.handler = handler;    }

• corePoolSize：线程池中核心线程的数量。

  线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。任务提交到线程池后，首先会检查当前线程数是否达到了corePoolSize，如果没有达到的话，则会创建一个新线程来处理这个任务。

• maximumPoolSize：线程池中最大线程数量。

  当前线程数达到corePoolSize后，如果继续有任务被提交到线程池，会将任务缓存到工作队列中。如果队列也已满，则会去创建一个新线程来出来这个处理。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。

• keepAliveTime：线程池中空闲线程的存活时间。

  一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么超过keepAliveTime设定的时间后，这个空闲线程会被销毁。

• unit：空闲线程的存活时间单位。

  java.util.concurrent.TimeUnit 枚举类。

• workQueue：工作队列。

  存放工作任务的队列，任务调度时会从该队列取出任务。JDK提供了四种实现队列：

  1. ArrayBlockingQueue

  其是一个基于数组的阻塞队列，底层使用数组进行元素的存储。创建该阻塞队列实例需要指定队列容量，故其是一个有界队列。在并发控制层面，无论是入队还是出队操作，均使用同一个ReentrantLock可重入锁进行控制，换言之生产者线程与消费者线程间无法同时操作。

  2. LinkedBlockingQuene

  其是一个基于链表的阻塞队列，底层使用链表进行元素的存储。该阻塞队列容量默认为 Integer.MAX_VALUE，即如果未显式设置队列容量时可以视为是一个无界队列；反之构建实例过程中指定队列容量，则其就是一个有界队列。在并发控制层面，其使用了两个ReentrantLock可重入锁来分别控制对入队、出队这两种类型的操作。使得生产者线程与消费者线程间可以同时操作提高效率。

  3. SynchronousQuene

  其是一个同步队列。特别地是由于该队列没有容量无法存储元素，故生产者添加的数据会直接被消费者获取并且立刻消费。所以当生产者线程添加数据时，如果此时恰好有一个消费者已经准备好获取队头元素了，则会添加成功；否则要么添加失败返回false要么被阻塞。如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

  4. PriorityBlockingQueue

  线程安全版本的优先级队列PriorityBlockingQueue，其是一个支持优先级的无界阻塞队列。底层使用数组实现元素的存储、最小堆的表示。默认使用元素的自然排序，即要求元素实现Comparable接口；或者显式指定比较器Comparator。在并发控制层面，无论是入队还是出队操作，均使用同一个ReentrantLock可重入锁进行控制。值得一提的是，在创建该队列实例时虽然可以指定容量。但这并不是队列的最终容量，而只是该队列实例的初始容量。一旦后续过程队列容量不足，其会自动进行扩容。值得一提的是，为了保证同时只有一个线程进行扩容，其内部是通过CAS方式来实现的，而不是利用ReentrantLock可重入锁来控制。故PriorityBlockingQueue是一个无界队列。

  以上队列相关描述取自： Java多线程之阻塞队列（知乎文章）

• threadFactory：线程工厂。

  创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程。

• handler：拒绝策略。

  当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，就会执行相应的拒绝策略。jdk中提供了4中拒绝策略：

  1. CallerRunsPolicy

  只要线程池没有关闭，就交由调用方线程运行。谁提交任务谁来执行这个任务，即将任务执行放在提交的线程里面，减缓了线程的提交速度，相当于负反馈。在提交任务线程执行任务期间，线程池又可以执行完部分任务，从而腾出空间来。

  使用场景：一般不允许失败的、对性能要求不高、并发量较小的场景下使用。

  2. AbortPolicy

  直接丢弃任务，抛出RejectedExecutionException异常。

  3. DiscardPolicy

  直接丢弃任务，什么都不做。

  4. DiscardOldestPolicy

  弃任务队列中等待事件最长的，即最老的任务。

线程和线程池的使用规范

java提供了几种常见的线程池创建方式：

• FixThreadPool 可重用固定线程池

  线程池的大小一旦达到设定数量就会保持不变。

• SingleThreadExcutor 单线程化的线程池

  只有一个线程的线程池，任务按照提交的次序顺序执行的。

• CachedThreadPool 可缓存线程池

  此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。线程池的线程数可达到Integer.MAX_VALUE，即2147483647。

具体实现可自行查看JDK源码。

注意：

1. 对于线程资源应通过线程池提供，避免自行显示创建线程。

2. 虽然java提供了以上三种常见的线程池创建方式，但是以上三种队列，队列长度或者线程数的最大限制可达到Integer.MAX_VALUE，可能导致内存溢出，所以线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor的方式。

最新版阿里巴巴泰山版《Java开发手册》对线程和线程池的使用也提出了强制类型要求，如下图：