线程创建的三种方式及区别

最新推荐文章于 2024-08-05 22:47:16 发布

Dawn_SSR

最新推荐文章于 2024-08-05 22:47:16 发布

阅读量3.1k

点赞数 2

分类专栏： # JavaSE 文章标签： java

本文链接：https://blog.csdn.net/zzuryzjq/article/details/118695588

版权

JavaSE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文首发地址：https://www.dawnsite.cn/archives/256.html

文章目录

一. 创建方式

1. 继承Thread类

定义Thread类的子类，并重写该类的run方法。
创建Thread子类的实例，即创建了线程对象。
调用线程对象的start()方法来启动线程。

package Thread;

/*
  1.继承Thread类
  2.重写run()方法
  3.调用start()方法开启线程
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
    }

    public static void main(String[] args) {
        //创建Thread子类的实例
        TestThread testThread = new TestThread();
        //调用start()方法开启线程
        testThread.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
    }
}

当多线程没有开启时，代码只执行主线程里面main()方法的代码，当开启线程后，经过cpu调度后开始执行（线程开启后不一定立即执行）

运行结果：

2. 实现Runnable接口

实现Runnable接口，并重写该接口的run()方法。
创建Runnable实现类的实例，并用该实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

package Thread;

/*
  1.实现Runnable接口
  2.重写run()方法
  3.创建Runnable接口实现类实例，并将该实例放入Thread的target来创建Thread对象
  4.调用start()方法开启线程
 */
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口实现类实例
        TestRunnable testRunnable = new TestRunnable();
        //该实例放入Thread的target来创建Thread对象
        //调用start()方法开启线程
//        Thread thread = new Thread(testRunnable);
//        thread.start();
        new Thread(testRunnable).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
    }
}

执行结果：

3. 实现Callable接口

实现Callable接口并指定返回值，然后实现call()方法。
创建Callable实现类的实例，使用FutureTask包装类来包装Callable对象。
使用FutureTask对象作为Thread对象的target创建并启动新线程。
调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
  1.实现Callable接口。
  2.重写call()方法。
  3.创建Callable接口实现类实例，使用FutureTask包装类来包装Callable实例对象。
  4.使用FutureTask对象作为Thread的target来创建Thread对象。
  5.调用start()方法开启线程。
  6.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
 */
public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        //重写call()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口实现类实例
        TestCallable testCallable = new TestCallable();
        //使用FutureTask包装类来包装Callable实例对象
        FutureTask<Boolean> task = new FutureTask<>(testCallable);
        //使用FutureTask对象作为Thread的target来创建Thread对象
        //调用start()方法开启线程
        new Thread(task).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
        //调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
        System.out.println(task.get());  //获取call()的返回值。若调用时call()方法未返回，则会阻塞线程等待返回值
    }
}

执行结果：

二. 创建线程三种方式的优缺点

1. 继承Thread类

优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可。
缺点：java是单继承的，故无法再继承其他类。

2. 实现Runnable接口

优点：线程类只是实现了Runnable接口，还可以继承其他类。这种情况下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将cpu代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

3. Runnable和Callable的区别

Runnable规定的方法是run()，Callable规定的是call()。
Runnable的任务执行后无返回值，Callable的任务执行后有返回值。
call()方法可以抛出异常，run()方法不可以，因为run()方法本身没有抛出异常，所以自定义的线程类在重写run()方法的时候也无法抛出异常。
运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消人物的执行，还可获取执行结果。