Java多线程（二）：建立线程的三种方法-CSDN博客

本文链接：https://blog.csdn.net/m0_67314592/article/details/139568054

第一种：直接继承Thread类

Thread类的基本用法

· 继承Thead类即可使一个类以线程的形式运行
· run方法为线程入口，称为线程体，run()运行结束，此线程终止。
· run方法在Thread类中已经被定义，但它没有做任何事情，所以当成创建一个Thread子类时，通常会重写run方法来定义线程应该执行的任务（@Override为重写标记）
注意run方法并非抽象类

示范一：

//创建线程的第一种方法：继承于Thread类
public class MyThread extends Thread{
    //重写run方法的标记
    @Override
    public void run(){//run方法是线程的入口，就是线程执行的任务方法
        for(int i = 0; i < 10; i++){
            System.out.println("锄禾日当午"+i);
        }

    }
}

· 执行路径的出发方式并非调用run方法，而是通过Thread对象的start()方法来启动任务
· run()不能由程序员显式调用, 必须回调：由start()方法来调用。

示范一的使用：

 //创建线程的第一种方法：继承于Thread类
public class Demo01 {
    public static void main(String[] args) {
        MyThread m = new MyThread();
        m.start();
        for(int i = 0; i < 10; i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}

此时，主线程（汗滴禾下土）和子线程（锄禾日当午）并发执行，所以并非严格交替打印。

第二种：以Runnable实现

Runnable接口的基本用法

· Runnable接口只有一个run（）方法且是抽象的
· 所以必须为run()方法提供实现

示范二：

public class MyRunnable implements Runnable{//相当于写了一个任务，交给线程执行
    @Override
    public void run(){
        for(int i = 0; i < 10; i++){
            System.out.println("床前明月光"+i);
        }
    }
}

实现Runnable接口的好处：
1.通过创建任务，给线程分配以实现多线程，更适合多线程执行相同任务的情况
2.避免了单继承的局限性，一个类只能继承一个类，但是可以实现多个接口
3.任务和线程分离，实现解耦，代码更清晰，且提高健壮性
*4.线程池（后续内容）只能放入实现Runnable或Callable类的线程(第三种），不能放入继承Thread的线程

示范二的使用：

public class Demo01_2 {
    public static void main(String[] args) {
        //实现Runnable
        //创建一个任务对象r
        MyRunnable r = new MyRunnable();
        //创建一个线程对象t,将r作为参数传递给t（为线程分配任务r）
        Thread t = new Thread(r);
        //调用t.start()方法启动线程
        t.start();
        for(int i = 0; i < 10; i++){
            System.out.println("疑是地上霜"+i);
        }
    }
}

使用流程
1.创建一个任务对象r
2.创建一个线程对象t,将r作为参数传递给t（为线程分配任务r）
3.调用t.start()方法启动线程

第三种：带返回值的Callable接口（需泛型编程基础）

Callable的基本理解

· 前两种像是创建新的执行路径，与主线程并发执行，互不干扰
· Callable更像是主线程指派一个任务，主线程可获取其返回值，即可并发执行，也可排队执行

Callable与Runnable的异同

同

都是接口
都用与多线程
都借助Thread.start()启动线程

异

call()方法与run()方法
Runnable无返回值而Callble有
call()可抛出异常而run()

Callable的基本使用

示范三：

    static class MyCallable implements Callable<Integer>{//即第一步：编写类实现Callable接口,并实现Call方法
        @Override
        public Integer call() throws Exception {
//            Thread.sleep(3000);
            for(int i = 0; i < 10; i++){
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }

示范三的使用：
并发执行场景：不使用get()

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//使用Callable接口创建线程
public class Demo11 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> c = new MyCallable();//创建一个Callable接口的实现类的对象
        FutureTask<Integer> task = new FutureTask<>(c);//创建任务对象，并将Callable接口的实现类对象传递给任务对象
//        task.isDone();//判断子线程是否执行结束
        new Thread(task).start();//创建线程对象，并将任务对象传递给线程对象
//        Integer j = task.get();//获取返回值测试
//        System.out.println("返回值为：" + j);
        for(int i = 0; i < 10; i++){//如果不使用get()则交替执行
            Thread.sleep(100);
            System.out.println(i);
        }
    }
    static class MyCallable implements Callable<Integer>{//即第一步：编写类实现Callable接口,并实现Call方法
        @Override
        public Integer call() throws Exception {
//            Thread.sleep(3000);
            for(int i = 0; i < 10; i++){
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }
    }
}

*排队执行场景：使用get()以获取返回值

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

//使用Callable接口创建线程
public class Demo11 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> c = new MyCallable();//创建一个Callable接口的实现类的对象
        FutureTask<Integer> task = new FutureTask<>(c);//创建任务对象，并将Callable接口的实现类对象传递给任务对象
//      task.isDone();//判断子线程是否执行结束
        new Thread(task).start();//创建线程对象，并将任务对象传递给线程对象
        Integer j = task.get();//获取返回值测试
        System.out.println("返回值为：" + j);
        for(int i = 0; i < 10; i++){
            Thread.sleep(100);
            System.out.println(i);
        }

    }
    static class MyCallable implements Callable<Integer>{//即第一步：编写类实现Callable接口,并实现Call方法
        @Override
        public Integer call() throws Exception {
//            Thread.sleep(3000);
            for(int i = 0; i < 10; i++){
                Thread.sleep(100);
                System.out.println(i);
            }
            return 100;
        }
    }
}