多线程实现的方式总结

快来打我* 2023-09-24 19:03 5阅读 0赞

#### JAVA多线程实现方式 ####

*   *  一、继承Thread类
     *  二、实现Runnable接口
     *  三、 实现callable接口
     *  四、线程池
     *   *  定长线程池（FixedThreadPool）
         *  定时线程池（ScheduledThreadPool）
         *  可缓存线程池（CachedThreadPool）
         *  单线程化线程池（SingleThreadExecutor）
         *  （ThreadPoolExecutor）
     *  创建线程对比
     *   *  1.实现Runnable或Callable接口比继承Thread类的优势
         *  Callable和Runnable之间的区别
     *  参考

JAVA多线程实现方式主要有四种：  
继承Thread类、  
实现Runnable接口、  
Callable、Future实现有返回结果的多线程。  
使用ExecutorService

### 一、继承Thread类 ###

启动线程的唯一方法就是通过Thread类的start()实例方法。  
start()方法是一个native方法，它将启动一个新线程，并执行run()方法。

/**
     * @author Myli
     * @create 2023-02-19 5:51
     */
    public class testmyli {
        
        public static void main(String[] args) {
        
            MyThread myThread1 = new MyThread();
            myThread1.start();
        }
    }
    
    class MyThread extends Thread {
        
        public void run() {
        
            System.out.println("MyThread.run()");
        }
    }

Thread本质上也是实现了Runnable接口的一个实例，  
![在这里插入图片描述][a8bd0bec91bf40c895a525b9428ad89c.png]

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

### 二、实现Runnable接口 ###

众所周知，java是单继承的，如果某个类他已经有父类了，就无法直接extends Thread，此时，如果要实现多线程，可以通过实现一个Runnable接口来进行

/**
     * @author Myli
     * @create 2023-02-21 0:27
     */
    public class testrunable {
        
        public static void main(String[] args) {
        
        //new一个MyThread，
            MyThread myThread = new MyThread();
           //new一个Thread
            Thread thread = new Thread(myThread);
            thread.start();
        }
        
        static class MyThread extends OtherClass implements Runnable {
        
            public void run() {
        
                System.out.println("MyThread.run()");
            }
        }
    }

![在这里插入图片描述][270ae7fb8d0544148597705e8b6a87a5.png]  
![在这里插入图片描述][9be08165591c4f1aaa7b8d808baec532.png]

### 三、 实现callable接口 ###

/**
     * @author Myli
     * @create 2023-02-21 0:44
     */
    public class testcallable {
        
        public static void main(String[] args) {
        
    
            //调用callable 可以有返回值 可以捕获异常
            Callable<String> tc = new TestCallable();
    
            FutureTask<String> task = new FutureTask<String>(tc);
    
            new Thread(task).start();
            try {
        
                System.out.println(task.get());//获取返回值
            } catch (InterruptedException | ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    
         static class TestCallable implements Callable<String> {
        
            @Override
            public String call() throws Exception {
        
                System.out.println("实现callable：" + Thread.currentThread().getName());
                return "callable返回";
            }
        }
    
    }

![在这里插入图片描述][272e4916f9a44fe7ab2b9637938017a6.png]  
![在这里插入图片描述][9d336d1856d54eb69f4f7d540f52dc5a.png]  
![在这里插入图片描述][b9b9baa505d84293b26cf50f891ccbb9.png]  
![在这里插入图片描述][6030e74ff98748ab8a52c94ad9b6561b.png]

### 四、线程池 ###

常见的有  
定长线程池（FixedThreadPool）  
定时线程池（ScheduledThreadPool ）  
可缓存线程池（CachedThreadPool）  
单线程化线程池（SingleThreadExecutor）  
完全手动的 （ThreadPoolExecutor）

#### 定长线程池（FixedThreadPool） ####

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    // 2. 创建好Runnable类线程对象 & 需执行的任务
    Runnable task =new Runnable(){
        
      public void run() {
        
         System.out.println("执行任务啦");
      }
    };
    // 3. 向线程池提交任务
    fixedThreadPool.execute(task);

![在这里插入图片描述][f1ac770148914ec287159c3b884cc702.png]  
![在这里插入图片描述][32948d889d944e669e24f12bf269a79b.png]

#### 定时线程池（ScheduledThreadPool） ####

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

#### 可缓存线程池（CachedThreadPool） ####

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

#### 单线程化线程池（SingleThreadExecutor） ####

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

#### （ThreadPoolExecutor） ####

Executors 的 4 个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

其实 Executors 的 4 个功能线程有如下弊端：

FixedThreadPool 和 SingleThreadExecutor：主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue，  
可能会耗费非常大的内存，甚至 OOM。  
CachedThreadPool 和 ScheduledThreadPool：主要问题是线程数最大数是 Integer.MAX\_VALUE，  
可能会创建数量非常多的线程，甚至 OOM。

// 创建线程池
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
                                                 MAXIMUM_POOL_SIZE,
                                                 KEEP_ALIVE,
                                                 TimeUnit.SECONDS,
                                                 sPoolWorkQueue,
                                                 sThreadFactory);
    // 向线程池提交任务
    threadPool.execute(new Runnable() {
        
        @Override
        public void run() {
        
            ... // 线程执行的任务
        }
    });
    // 关闭线程池
    threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
    threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

![在这里插入图片描述][aa0dbbebe1fd4d67a19db7e7490c14b2.png]  
当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。  
CallerRunsPolicy：由调用线程处理该任务。  
DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。  
DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

### 创建线程对比 ###

#### 1.实现Runnable或Callable接口比继承Thread类的优势 ####

（1）Runnable或Callable接口适合多个线程进行资源共享

（2）java中单一继承，但是多接口实现，提高扩展性

（3）增加程序的健壮性，代码和数据独立

（4）线程池只能放入Runable或Callable接口实现类，不能直接放入继承Thread的类

#### Callable和Runnable之间的区别 ####

(1) Callable重写的是call()方法，Runnable重写的方法是run()方法

(2) call()方法执行后可以有返回值，run()方法没有返回值

(3) call()方法可以抛出异常，run()方法不可以

(4) 运行Callable任务可以拿到一个Future对象，表示异步计算的结果 。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果

### 参考 ###

链接: [Java 多线程：彻底搞懂线程池][Java]  
链接: [创建线程的三种方式及区别][Link 1]  
部分参考已找不到原出处

[a8bd0bec91bf40c895a525b9428ad89c.png]: https://img-blog.csdnimg.cn/a8bd0bec91bf40c895a525b9428ad89c.png
[6dfdea58352d4795b0906fe5645d755e.png]: https://img-blog.csdnimg.cn/6dfdea58352d4795b0906fe5645d755e.png
[270ae7fb8d0544148597705e8b6a87a5.png]: https://img-blog.csdnimg.cn/270ae7fb8d0544148597705e8b6a87a5.png
[9be08165591c4f1aaa7b8d808baec532.png]: https://img-blog.csdnimg.cn/9be08165591c4f1aaa7b8d808baec532.png
[272e4916f9a44fe7ab2b9637938017a6.png]: https://img-blog.csdnimg.cn/272e4916f9a44fe7ab2b9637938017a6.png
[9d336d1856d54eb69f4f7d540f52dc5a.png]: https://img-blog.csdnimg.cn/9d336d1856d54eb69f4f7d540f52dc5a.png
[b9b9baa505d84293b26cf50f891ccbb9.png]: https://img-blog.csdnimg.cn/b9b9baa505d84293b26cf50f891ccbb9.png
[6030e74ff98748ab8a52c94ad9b6561b.png]: https://img-blog.csdnimg.cn/6030e74ff98748ab8a52c94ad9b6561b.png
[f1ac770148914ec287159c3b884cc702.png]: https://img-blog.csdnimg.cn/f1ac770148914ec287159c3b884cc702.png
[32948d889d944e669e24f12bf269a79b.png]: https://img-blog.csdnimg.cn/32948d889d944e669e24f12bf269a79b.png
[34ff42b9f95d483bbc07ca9b33459111.png]: https://img-blog.csdnimg.cn/34ff42b9f95d483bbc07ca9b33459111.png
[2e1b71526e4a4c4386dcfa8b099cd3de.png]: https://img-blog.csdnimg.cn/2e1b71526e4a4c4386dcfa8b099cd3de.png
[1c2f8ae3b87c40d89f6031bb13638417.png]: https://img-blog.csdnimg.cn/1c2f8ae3b87c40d89f6031bb13638417.png
[aa0dbbebe1fd4d67a19db7e7490c14b2.png]: https://img-blog.csdnimg.cn/aa0dbbebe1fd4d67a19db7e7490c14b2.png
[Java]: https://jimmysun.blog.csdn.net/article/details/95225769
[Link 1]: https://blog.csdn.net/m0_58354370/article/details/126259113