Java多线程创建方式和使用记录

本是古典何须时尚 2023-10-06 14:30 12阅读 0赞

#### 前言 ####

项目中涉及一些线程使用的改造,在使用修改线程的过程中,踩了不少坑.在此归纳总结一下,方便日后避开这些坑.

#### java使用线程的方法 ####

1.继承Thread类  
2.实现Runnable接口  
3.使用ExecutorService、Callable、Future实现

其中 1和 2两种方式创建的线程 执行结束都没有返回值,  
执行 run方法不可以抛出异常  
3是创建线程 有返回值、可以抛出异常.

##### 1.继承Thread类 #####

代码示例:

package com.fl.thread;
    
    public class TestThread  extends Thread{
        
        public void run(){
        
            super.run();
            System.out.println("子线程执行了--------");
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            TestThread testThread = new TestThread();
            testThread.start();
            System.out.println("主线程执行----------");
        }
    }

这种线程的使用方式 本质上其实 也是实现Runnable接口的  
一个实例,它代表一个线程的实例,启动线程的唯一方法是  
通过Thread 类的start 方法,start 方法时一个原生方法,  
它会启动一个新线程,并且执行run()方法. 这种的局限性是 使用继承 Thread 类的方式创建线程时，是不支持多继承.  
为了实现多继承要实现Runnable 接口.  
执行的结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ_size_16_color_FFFFFF_t_70_pic_center]  
注意: 在使用多线程时，运行结果与调用顺序是无关的(这里的结果不代表线程的执行顺序，线程是并发执行的，如果多运行几次，打印顺序可能会不一样。多线程的运行过程中，CPU是以不确定的方式去执行线程的，故运行结果与代码的执行顺序或者调用顺序无关)。  
调用run()方法 知识普通的方法调用(`main方法中应该调用的是myThread的start方法，而不是run()方法。调用start()方法是告诉CPU此线程已经准备就绪可以执行，进而系统有时间就会来执行其run()方法。而直接调用run()方法，则不是异步执行，而是等同于调用函数般按顺序同步执行，这就失去了多线程的意义了。`),不会启动线程.如果多次  
调用 start 方法,会抛出 `IllegalThreadStateException` 异常.

##### 2.实现Runnable 接口 #####

这种方法用的比较多,就是把继承Thread类改为实现Runnable接口.  
代码示例:

package com.fl.thread;
    
    public class MyRunnable  implements Runnable{
        
        public void run() {
        
            System.out.println("执行子线程------");
        }
    }
    
    //测试
    public class TestRunnable {
        
        public static void main(String[] args) {
        
            MyRunnable runnable = new MyRunnable();
            Thread thread = new Thread(runnable);
            thread.start();
            System.out.println("主线程运行结束--------");
        }
    }

运行结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ_size_16_color_FFFFFF_t_70_pic_center 1]  
这里我们可看出 main中可以看到真正创建新线程还是通过Thread创建：  
Thread thread = new Thread(runnable);  
这一步Thread类的作用就是把run()方法包装成线程执行体，然后依然通过start去告诉系统这个线程已经准备好了可以安排执行。

#### 3.使用ExecutorService、Callable、Future实现 ####

ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类. 要了解这框架 大家可以看下并发编程 的书籍.  
实现Callable接口，重写call()方法，然后包装成java.util.concurrent.FutureTask, 再然后包装成Thread.

Callable：有返回值的线程，能取消线程，可以判断线程是否执行完毕.

代码示例:

package com.fl.thread;
    
    import java.util.concurrent.Callable;
    
    public class MyCallable  implements Callable<Integer> {
        
        public Integer call() throws Exception {
        
            System.out.println("获取当前线程的名称"+Thread.currentThread().getName()+
                    "当前线程的Id"+Thread.currentThread().getName());
            int count = 0;
            for (int i = 0; i <= 200000; i++) {
        
                count += i;
            }
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId()+"end---");
            return count;
        }
    }
    
    //测试
    public class TestMyCallable {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            // 将Callable包装成FutureTask，FutureTask也是一种Runnable
            MyCallable callable = new MyCallable();
            FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
            new Thread(futureTask).start();
    
            // get方法会阻塞调用的线程
            Integer sum = futureTask.get();
            System.out.println(Thread.currentThread().getName() + Thread.currentThread().getId() + "=" + sum);
        }
    }

Callable它也是一种函数式接口:

@FunctionalInterface
    public interface Callable<V> {
        
        V call() throws Exception;
    }

上边测试中用到了 FutureTask

它的用法

public class FutureTask<V> implements RunnableFuture<V> {
        
    	// 构造函数
    	public FutureTask(Callable<V> callable);
    	
    	// 取消线程
    	public boolean cancel(boolean mayInterruptIfRunning);
    	// 判断线程
    	public boolean isDone();
    	// 获取线程执行结果
    	public V get() throws InterruptedException, ExecutionException;
    }

FutureTask 实现 RunnableFuture

public interface RunnableFuture<V> extends Runnable, Future<V> {
        
        void run();
    }

比较 总结一下 这三种方式

Thread: 继承方式, 不建议使用, 因为Java是单继承的，继承了Thread就没办法继承其它类了，不够灵活
    Runnable: 实现接口，比Thread类更加灵活，
    没有单继承的限制
    Callable: Thread和Runnable都是重写的run()方法
    并且没有返回值，Callable是重写的call()方法并且
    有返回值并可以借助FutureTask类来判断线程是否已经
    执行完毕或者取消线程执行
    当线程不需要返回值时使用Runnable，需要返回值时就使用Callable，一般情况下不直接把线程体代码放到
    Thread类中，一般通过Thread类来启动线程
    Thread类是实现Runnable，Callable封装成FutureTask，FutureTask实现RunnableFuture，
    RunnableFuture继承Runnable，所以Callable
    也算是一种Runnable，
    所以三种实现方式本质上都是Runnable实现

关系 ExecutorService 用法  
ExecutorService是Java提供的线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。它可以有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞，同时提供定时执行、定期执行、单线程、并发数控制等功能，也不用使用TimerTask了。

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)

所有的线程池 最终都是通过这方法来创建的.  
详细的可见  
[https://blog.csdn.net/weixin\_43975771/article/details/108034443][https_blog.csdn.net_weixin_43975771_article_details_108034443]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/2020081611015297.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200816111323345.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk3NTc3MQ==,size_16,color_FFFFFF,t_70#pic_center
[https_blog.csdn.net_weixin_43975771_article_details_108034443]: https://blog.csdn.net/weixin_43975771/article/details/108034443