线程开启的三种方式

线程开启的三种方式

方法一：继承Thread

1. 定义一个类继承Thread
2. 重写run方法
3. 创建线程对象
4. 开启线程

public static void main(String[] args) {
    //创建线程对象
    MyThread myThread = new MyThread();
    //开启线程
    myThread.start();
}
//定义一个类继承Thread
public static class MyThread extends Thread {
    //重写run方法
    @Override
    public void run() {
        //todo task
        super.run();
    }
}

方法二：实现Runnable接口

1. 定义一个类实现Runnable接口
2. 重写run方法
3. 在main方法(线程)中,创建线程对象,并启动线程.
   ① 创建线程类对象:
   Thread thread = new Thread(myThread);
   ② 调用线程对象的start方法:
   thread.start();

public static void main(String[] args) {
    MyThread myThread = new MyThread();
    //创建线程对象
    Thread thread = new Thread(myThread);
    //调用start方法
    thread.start();
}
//定义一个类实现Runnable接口
public static class MyThread implements Runnable {
    //重写run方法
    @Override
    public void run() {
        //todo task
    }
}

方法三：实现Callable接口

1. 定义一个类实现Callable接口

2. 重写call方法

3. 在main方法(线程)中,创建Callable对象，创建任务将Callable对象传进来，创建线程对象将任务传进来，并启动线程.

   ① 创建Callable对象:
   Callable c = new MyCallable();

   ② 创建任务将Callable对象传进来:
   FutureTask task = new FutureTask<>©;

   ③ 创建线程类对象:
   Thread thread = new Thread(task);

   ④ 调用线程对象的start方法:
   thread.start();

public static void main(String[] args) {
    //创建Callable对象
    Callable<Integer> c = new MyCallable();
    //创建任务将Callable对象传进来
    FutureTask<Integer> task = new FutureTask<>(c);
    //创建线程对象
    Thread thread = new Thread(task);
    //调用start方法
    thread.start();
}
//定义一个类实现Callable<V>接口
public static class MyCallable implements Callable<Integer> {
    //重写call方法
    @Override
    public Integer call() throws Exception {
        //todo task
        return null;
    }
}