Java进阶（5）——创建多线程的方法extends Thread和implements Runnable的对比 & 线程池及常用的线程池

ゞ浴缸里的玫瑰 2023-10-15 08:06 4阅读 0赞

#### 目录 ####

*  引出
 *  创建多线程的方法
 *   *  Thread类创建多线程
     *  Runnable接口创建多线程
     *  Thread类的常用方法
     *  两者的对比
 *  线程池
 *   *  是啥？为啥用？
     *  结合案例理解常用的线程池
     *  继承Runnable接口的工人实体类
     *  newSingleThreadExecutor（单线程）
     *  newFixedThreadPool（加锁）
     *  newCachedThreadPool
     *  newScheduledThreadPool（定时任务）
     *  newSingleThreadScheduledExecutor
 *  总结

## 引出 ##

--------------------

1.创建多线程两种方法，继承thread，实现runnable，常用runnable；  
2.线程池，管理线程，控制并发；  
3.常用的线程池，newFixedThreadPool定容量；  
4.newCachedThreadPool容量大，Integer.MAX\_VALUE；  
5.newScheduledThreadPool（定时任务），newSingleThreadScheduledExecutor单线程的线程池的定时任务；  
6.newSingleThreadExecutor（单线程），单线程的线程池；

![在这里插入图片描述][c28089cbe1c1466794083896673b7fa6.png]

![在这里插入图片描述][01302e5f99ae446ea84c04d4a895ea7a.png]

## 创建多线程的方法 ##

JDK提供了`Thread`类和`Runnable`接口来让我们实现自己的“线程”类。

*  继承`Thread`类，并重写`run`方法；
 *  实现`Runnable`接口的`run`方法；

### Thread类创建多线程 ###

> 继承`Thread`类：

package com.tianju.book.jpa.syn;
    
    public class Demo1 {
        
        public static class MyThread extends Thread{
        
            @Override
            public void run() {
        
                System.out.println("通过继承Thread创建多线程");
            }
        }
    
        public static void main(String[] args) {
        
            MyThread myThread = new MyThread();
            myThread.start();
        }
    }

注意要调用`start()`方法后，该线程才算启动！

> 我们在程序里面调用了start()方法后，虚拟机会先为我们创建一个线程，然后等到这个线程第一次得到时间片时再调用run()方法。
> 
> 注意不可多次调用start()方法。在第一次调用start()方法后，再次调用start()方法会抛出IllegalThreadStateException异常。

![在这里插入图片描述][26ca4904fc7c404eb668a112f0caaf95.png]

### Runnable接口创建多线程 ###

![在这里插入图片描述][e3d40a5672084a37bb06161463282862.png]

@FunctionalInterface
    public interface Runnable {
        
        public abstract void run();
    }

![在这里插入图片描述][f637cbbd5ae64349b8d76cb24ce4017e.png]

package com.tianju.book.jpa.syn;
    
    public class Demo2 {
        
        public static class MyThread implements Runnable{
        
    
            @Override
            public void run() {
        
                System.out.println("继承runnable实现多线程");
            }
        }
    
        public static void main(String[] args) {
        
            Thread thread = new Thread(() -> {
        
                System.out.println("匿名内部类");
                new MyThread().run();
            });
            thread.start();
        }
    }

### Thread类的常用方法 ###

这里介绍一下Thread类的几个常用的方法：

*  currentThread()：静态方法，返回对当前正在执行的线程对象的引用；
 *  start()：开始执行线程的方法，java虚拟机会调用线程内的run()方法；
 *  yield()：yield在英语里有放弃的意思，同样，这里的yield()指的是当前线程愿意让出对当前处理器的占用。这里需要注意的是，就算当前线程调用了yield()方法，程序在调度的时候，也还有可能继续运行这个线程的；
 *  sleep()：静态方法，使当前线程睡眠一段时间；
 *  join()：使当前线程等待另一个线程执行完毕之后再继续执行，内部调用的是Object类的wait方法实现的；

### 两者的对比 ###

实现一个自定义的线程类，可以有继承`Thread`类或者实现`Runnable`接口这两种方式，它们之间有什么优劣呢？

*  由于Java“单继承，多实现”的特性，Runnable接口使用起来比Thread更灵活。
 *  Runnable接口出现更符合面向对象，将线程单独进行对象的封装。
 *  Runnable接口出现，降低了线程对象和线程任务的耦合性。
 *  如果使用线程时不需要使用Thread类的诸多方法，显然使用Runnable接口更为轻量。

所以，我们通常优先使用“实现`Runnable`接口”这种方式来自定义线程类。

## 线程池 ##

### 是啥？为啥用？ ###

线程池是一种用于管理和复用线程的机制。它是一种线程管理的抽象概念，可以有效地管理线程的创建、执行和销毁，以提高应用程序的性能和资源利用率。

线程池中包含一组预先创建的线程，这些线程可以被重复使用来执行任务。当有任务需要执行时，线程池中的线程会被分配给任务，并在任务完成后返回线程池，以便可以被其他任务复用。这样可以避免频繁地创建和销毁线程，减少了线程创建和销毁的开销，提高了系统的响应速度和资源利用率。

使用线程池主要有以下三个原因：

1.  创建/销毁线程需要消耗系统资源，线程池可以**复用已创建的线程**。
2.  **控制并发的数量**。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
3.  **可以对线程做统一管理**。

### 结合案例理解常用的线程池 ###

`Executors`类中提供的几个静态方法来创建线程池

### 继承Runnable接口的工人实体类 ###

> name：工人名字，
> 
> workTime：工作时间，用java的毫秒模拟现实中的1分钟
> 
> materials：物料的数量，假设一共有100个物料；

package com.tianju.book.jpa.syn;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 工厂仿真的工人
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Worker implements Runnable{
        
        private String name;
    
        private Integer workTime;
    
        private static Integer materials=100; // 物料数量
    
        @Override
        public void run() {
        
            System.out.println(name+"开始工作");
            try {
        
                Thread.sleep(workTime); // 模拟工作时间
                materials--; // 每次消耗1个物料
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            System.out.println(name+"工作完成，耗时"+workTime+"分钟，"+"当前剩余物料："+materials);
        }
    }

### newSingleThreadExecutor（单线程） ###

> 创建一个单线程的线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

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

有且仅有一个核心线程（ corePoolSize == maximumPoolSize=1），使用了LinkedBlockingQueue（容量很大），所以，**不会创建非核心线程**。所有任务按照**先来先执行**的顺序执行。如果这个唯一的线程不空闲，那么新来的任务会存储在任务队列里等待执行。

package com.tianju.book.jpa.syn;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 进行工厂的仿真
     */
    public class FactorySimulationSingle {
        
    
        public static void main(String[] args) {
        
            // 工人池，单线程的线程池
            ExecutorService workerPool = Executors.newSingleThreadExecutor();
            for (int i= 1;i<10;i++){
        
                Worker worker = new Worker("worker" + i, i * 10);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
            Thread thread2 = new Thread(() -> {
        
                for (int i = 1; i < 10; i++) {
        
                    Worker worker = new Worker("TH-worker" + i, i * 10);
                    workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
                }
            });
            thread2.start();
    
            try {
        
                Thread.sleep(20000);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            workerPool.shutdown();
        }
    }

![在这里插入图片描述][c6a47222741849d6838bfdce94b190d8.png]

### newFixedThreadPool（加锁） ###

> 创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。

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

核心线程数量和总线程数量相等，都是传入的参数nThreads，所以只能创建核心线程，不能创建非核心线程。因为LinkedBlockingQueue的默认大小是Integer.MAX\_VALUE，故如果核心线程空闲，则交给核心线程处理；如果核心线程不空闲，则入列等待，直到核心线程空闲。

**与CachedThreadPool的区别**：

*  因为 corePoolSize == maximumPoolSize ，所以FixedThreadPool只会创建核心线程。 而CachedThreadPool因为corePoolSize=0，所以只会创建非核心线程。
 *  在 getTask() 方法，如果队列里没有任务可取，线程会一直阻塞在 LinkedBlockingQueue.take() ，线程不会被回收。 CachedThreadPool会在60s后收回。
 *  由于线程不会被回收，会一直卡在阻塞，所以**没有任务的情况下， FixedThreadPool占用资源更多**。
 *  都几乎不会触发拒绝策略，但是原理不同。FixedThreadPool是因为阻塞队列可以很大（最大为Integer最大值），故几乎不会触发拒绝策略；CachedThreadPool是因为线程池很大（最大为Integer最大值），几乎不会导致线程数量大于最大线程数，故几乎不会触发拒绝策略。

> ExecutorService workerPool = Executors.newFixedThreadPool(1);
> 
> 设置线程池中线程数量为1，此时就等同于newSingleThreadExecutor

![在这里插入图片描述][5eb550960cb74fed8ee701a567ec9c54.png]

package com.tianju.book.jpa.syn;
    
    import java.util.concurrent.Executor;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 进行工厂的仿真
     */
    public class FactorySimulation {
        
    
        public static void main(String[] args) {
        
            // 工人池，固定大小为5
            ExecutorService workerPool = Executors.newFixedThreadPool(5);
    
            for (int i= 1;i<10;i++){
        
                Worker worker = new Worker("worker" + i, 1);
                workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
            }
    
            Thread thread1 = new Thread(() -> {
        
                for (int i = 1; i < 10; i++) {
        
                    Worker worker = new Worker("TH1-worker" + i, i * 10);
                    workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
                }
            });
    
            Thread thread2 = new Thread(() -> {
        
                for (int i = 1; i < 10; i++) {
        
                    Worker worker = new Worker("TH2-worker" + i, i * 10);
                    workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
                }
            });
    
            thread1.start();
            thread2.start();
    
            try {
        
                Thread.sleep(20000);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            workerPool.shutdown();
        }
    }

![在这里插入图片描述][d9792fc9f2e740c19edd1a7ce0f4b038.png]

### newCachedThreadPool ###

> 创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说VM)能够创建的最大线程大小。

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

`CacheThreadPool`的**运行流程**如下：

1.  提交任务进线程池。
2.  因为**corePoolSize**为0的关系，不创建核心线程，线程池最大为Integer.MAX\_VALUE。
3.  尝试将任务添加到**SynchronousQueue**队列。
4.  如果SynchronousQueue入列成功，等待被当前运行的线程空闲后拉取执行。如果当前没有空闲线程，那么就创建一个非核心线程，然后从SynchronousQueue拉取任务并在当前线程执行。
5.  如果SynchronousQueue已有任务在等待，入列操作将会阻塞。

当需要执行很多**短时间**的任务时，CacheThreadPool的线程复用率比较高， 会显著的**提高性能**。而且线程60s后会回收，意味着即使没有任务进来，CacheThreadPool并不会占用很多资源。

package com.tianju.book.jpa.syn;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 进行工厂的仿真
     */
    public class FactorySimulationCached {
        
    
        public static void main(String[] args) {
        
            // 工人池，固定大小为5 
            ExecutorService workerPool = Executors.newCachedThreadPool();
            Thread thread1 = new Thread(() -> {
        
                for (int i = 1; i < 10; i++) {
        
                    Worker worker = new Worker("TH1_worker" + i, i * 10);
                    workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
                }
            });
    
            Thread thread2 = new Thread(() -> {
        
                for (int i = 1; i < 10; i++) {
        
                    Worker worker = new Worker("TH2_worker" + i, i * 10);
                    workerPool.execute(worker); // 默认调用run方法，提交任务给线程池执行
                }
            });
    
            thread1.start();
            thread2.start();
    
            try {
        
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            workerPool.shutdown();
        }
    }

![在这里插入图片描述][a55c637474df43ed9d4e27f94167e98c.png]

### newScheduledThreadPool（定时任务） ###

> 创建一个定长线程池，支持定时及周期性任务执行。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
    //ScheduledThreadPoolExecutor():
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

![在这里插入图片描述][de7efe7f881f4c2a97233afbbccd70e4.png]

package com.tianju.book.jpa.syn;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 进行工厂的仿真
     */
    public class FactorySimulationScheduled {
        
    
        public static void main(String[] args) {
        
            // 工人池，固定大小为5  创建大小为20的定时线程池
            ScheduledExecutorService workerPool = Executors.newScheduledThreadPool(20);
            workerPool.schedule(new Worker("worker1,延迟1秒",10) ,1, TimeUnit.SECONDS);
            workerPool.scheduleAtFixedRate(new Worker("worker2,延迟2秒,后续每3秒执行1次",10), 2,3,TimeUnit.SECONDS);
            workerPool.scheduleAtFixedRate(new Worker("worker2,延迟2秒,后续每5秒执行1次",10), 3,5,TimeUnit.SECONDS);
    
            try {
        
                Thread.sleep(20000);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            workerPool.shutdown();
        }
    }

### newSingleThreadScheduledExecutor ###

> 创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

![在这里插入图片描述][f7a000ca818e46fb8d0a3c0e1f1d53a4.png]

package com.tianju.book.jpa.syn;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 进行工厂的仿真
     */
    public class FactorySimulationSingleS {
        
    
        public static void main(String[] args) {
        
            // 工人池，固定大小为5
            ScheduledExecutorService workerPool = Executors.newSingleThreadScheduledExecutor();
            Thread thread1 = new Thread(() -> {
        
                for (int i =1;i<10;i++){
        
                    workerPool.scheduleAtFixedRate(
                            new Worker("worker1-"+i, 3),
                            1, 3, TimeUnit.SECONDS);
                }
    
            });
            Thread thread2 = new Thread(() -> {
        
                for (int i=1;i<10;i++){
        
                    workerPool.scheduleAtFixedRate(
                            new Worker("worker2-"+i, 3),
                            1, 3, TimeUnit.SECONDS);
                }
    
            });
            thread1.start();
            thread2.start();
    
            try {
        
                Thread.sleep(20000);
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
            workerPool.shutdown();
    
        }
    }

--------------------

## 总结 ##

[c28089cbe1c1466794083896673b7fa6.png]: https://img-blog.csdnimg.cn/c28089cbe1c1466794083896673b7fa6.png
[01302e5f99ae446ea84c04d4a895ea7a.png]: https://img-blog.csdnimg.cn/01302e5f99ae446ea84c04d4a895ea7a.png
[26ca4904fc7c404eb668a112f0caaf95.png]: https://img-blog.csdnimg.cn/26ca4904fc7c404eb668a112f0caaf95.png
[e3d40a5672084a37bb06161463282862.png]: https://img-blog.csdnimg.cn/e3d40a5672084a37bb06161463282862.png
[f637cbbd5ae64349b8d76cb24ce4017e.png]: https://img-blog.csdnimg.cn/f637cbbd5ae64349b8d76cb24ce4017e.png
[c6a47222741849d6838bfdce94b190d8.png]: https://img-blog.csdnimg.cn/c6a47222741849d6838bfdce94b190d8.png
[5eb550960cb74fed8ee701a567ec9c54.png]: https://img-blog.csdnimg.cn/5eb550960cb74fed8ee701a567ec9c54.png
[d9792fc9f2e740c19edd1a7ce0f4b038.png]: https://img-blog.csdnimg.cn/d9792fc9f2e740c19edd1a7ce0f4b038.png
[a55c637474df43ed9d4e27f94167e98c.png]: https://img-blog.csdnimg.cn/a55c637474df43ed9d4e27f94167e98c.png
[de7efe7f881f4c2a97233afbbccd70e4.png]: https://img-blog.csdnimg.cn/de7efe7f881f4c2a97233afbbccd70e4.png
[f7a000ca818e46fb8d0a3c0e1f1d53a4.png]: https://img-blog.csdnimg.cn/f7a000ca818e46fb8d0a3c0e1f1d53a4.png