Java创建并执行线程的四种方法

小灰灰 2023-10-02 10:41 6阅读 0赞

### Java创建并执行线程的四种方法 ###

java里面创建线程有四种方式：  
**无返回：**

1.  **实现Runnable接口，重写run();**
2.  **继承Thread类，重写run();**  
    **有返回：**
3.  **实现Callable接口，重写call(),利用FutureTask包装Callable，并作为task传入Thread构造函数；**
4.  **利用线程池；**

下面来看看具体的创建方式：  
5. 继承Thread类，重写run()；  
创建：创建线程只需要继承Thread类，然后在run方法里写下线程要实现的任务即可；  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_15_color_FFFFFF_t_70_g_se_x_16]  
调用：通过调用start方法来启动线程而不能直接调用run方法。  
![在这里插入图片描述][b3adce345a974f9384a962ea2eeb008c.png]

① Thread类本质上是实现了Runnable接口，Thread对象代表一个线程的实例。  
② Runnable接口只有一个抽象的run()方法。  
③ 启动线程的唯一方法就是通过Thread类的start()实例方法。  
④ start()方法是一个native方法，它将启动一个新线程，并执行run()方法。  
⑤ 自定义类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。  
6. 创建任务，实现Runnable接口,重写run()。（受欢迎）  
因为Java只能单继承，继承了Thread类就不能再继承别的类了所以实现继承更推崇的是让线程类实现Runnable接口。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_16_color_FFFFFF_t_70_g_se_x_16]  
将Runnbale作为参数传入Thread的构造函数，创建Thread.  
![在这里插入图片描述][bdfd9a1b7b324af280b8fb9bd393e898.png]  
3. Callable接口只包含抽象方法V call()。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_20_color_FFFFFF_t_70_g_se_x_16]  
利用Callable接口创建并启动新线程的步骤：  
① 定义MyClass实现Callable接口；Class MyClass implements Callable  
② 重写call(),将执行的代码写入；  
③ 创建FutureTask的对象；FutureTask中定义了run(),run()内部调用了call(),并保存了call()的返回值；FutureTask futuretask = new FutureTask(newMyClass());  
④ 创建Thread的对象；Thread thread = new Thread(futuretask);//传入参数Runnable接口  
⑤ 启动线程;thread.start();\[图片\]  
⑥ 可通过FutureTask类的get()方法获得线程执行结束后的返回值，即call的返回值。futuretask.get();

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class MyThread {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            FutureTask<Integer> task = new FutureTask<Integer>(new CallableImpl());
            Thread thread = new Thread(task);
            thread.start();
            try {
        
                System.out.println("task.get() returns " + task.get());
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    }
    
    class CallableImpl implements Callable<Integer> {
        
    
        private static Integer value = 0;
    
        @Override
        public Integer call() throws Exception {
        
            System.out.println("执行call方法之前 value = " + value);
            value = value.intValue() + 1;
            System.out.println("执行call方法之后 value = " + value);
            return value;
        }
    }

运行结果：  
执行call方法之前 value = 0  
执行call方法之后 value = 1  
task.get() returns 1  
4. 通过线程池来创建线程  
① new ThreadPoolExecutor(…);  
② 创建任务Task implements Callable，重写run()方法；  
③ 通过线程池的execute()或submit()将任务command传入线程池;  
④ 获取返回值：

1.  实现Callable接口，重写call()方法  
    class CallableImpl implements Callable
2.  定义线程池  
    ThreadPoolExecutor executor
3.  利用submit()方法提交任务  
    Future<？> future = executor.submit(new CallableImpl());
4.  利用FutureTask类get()方法获取返回值  
    res = task.get();  
    这里future申明为Future对象，但是它是由FutureTask实现的，也可以直接申明为FutureTask future:

import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class MyThreadPool {
        
        public static void main(String[] args) throws InterruptedException, ExecutionException {
        
    
            ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                    new ArrayBlockingQueue<Runnable>(20));
            Future task;
            for (int i = 0; i < 5; i++) {
        
                task = executor.submit(new CallableImpl());
                System.out.println("线程返回结果：" + task.get());
            }
            executor.shutdown();
        }
    }
    
    class RunnableImpl implements Runnable {
        
    
        @Override
        public void run() {
        
            // TODO Auto-generated method stub
            System.out.println("hhh");
            System.out.println(Thread.currentThread().getName());
        }
    }

运行结果：  
执行call方法之前 value = 0  
执行call方法之后 value = 1  
线程返回结果：1  
执行call方法之前 value = 1  
执行call方法之后 value = 2  
线程返回结果：2  
执行call方法之前 value = 2  
执行call方法之后 value = 3  
线程返回结果：3  
执行call方法之前 value = 3  
执行call方法之后 value = 4  
线程返回结果：4  
执行call方法之前 value = 4  
执行call方法之后 value = 5  
线程返回结果：5

**总结：**  
线程的创建有四种方式：主要分为有返回和无返回，具体根据使用场景来选择。

1.  如果不需要返回且线程数量小，则建议采用实现Runnable接口，重写run()的方式；
2.  如果需要返回且线程数量小，则建议采用实现Callable接口，重写call()，利用FutureTask包装成一个Runnable，再作为参数传入Thread的构造方法的方式创建线程；
3.  如果线程数量较多，则建议采用线程池方式创建：execute提交任务实现无返回操作，submit提交任务实现有返回操作。

补充：FutureTask  
JDK1.8中FutureTask实现了RunnableFuture，而RunnableFuture顾名思义就是Runnable接口和Future接口的结合体。因此，FutureTask对象可以作为Runnable对象来用，比如

Thread thread = new Thread(new FutureTask<V>());

也可以作为Future来用。这就是Java的有魅力的地方。。。

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

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/e5da5454a6cc47f7a570a34b338e062e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQXJjaGllX2phdmE=,size_15,color_FFFFFF,t_70,g_se,x_16
[b3adce345a974f9384a962ea2eeb008c.png]: https://img-blog.csdnimg.cn/b3adce345a974f9384a962ea2eeb008c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_16_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/0f17300339a346c6852375ffa2cb622a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQXJjaGllX2phdmE=,size_16,color_FFFFFF,t_70,g_se,x_16
[bdfd9a1b7b324af280b8fb9bd393e898.png]: https://img-blog.csdnimg.cn/bdfd9a1b7b324af280b8fb9bd393e898.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAQXJjaGllX2phdmE_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/5206ab3ec78c46e2bfb83cd73ebba04d.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAQXJjaGllX2phdmE=,size_20,color_FFFFFF,t_70,g_se,x_16