【Java】线程创建的四种方式

1 前言

线程创建线程的方法一般可以分为四类：

通过实现Runnable接口来创建Thread线程

通过实现Callable接口来创建Thread线程

通过继承Thread类来创建一个线程

使用Executor框架来创建线程

2 创建线程的四种方式

2.1 实现Runnable接口创建Thread

通过实现Runnable接口来创建Thread线程，其步骤可以分为以下几步

步骤1：创建一个类实现Runnable接口

class TestRunnable implements Runnable{
    public void run(){
    }
}

步骤2：创建一个类对象

Runnable testRunnable = new TestRunnable();

步骤3：由Runnable创建一个Thead对象

Thread testThread = new Thread(testRunnable);

步骤4：启动线程：

testThread.start();

至此，通过实现Runnable接口来创建线程的步骤完成。

代码实现如下所示：
（1）TestRunnable类

package com.yds.test;
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        int i=0;
        while(i<10){
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            i++;
        }
    }
}

（2）Test类调用

package com.yds.test;

public class Test {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        //使用实现Runnable接口创建线程
        Runnable testRunnable = new TestRunnable();
        Thread testThread = new Thread(testRunnable);
        testThread.start();
    }

}

2.2 实现Callable接口来创建Thread线程

Callable是一个接口，只有一个call方法，用Callable接口创建Thread线程的步骤如下：

步骤1：创建实现Callable接口的类TestCallable

package com.yds.test;

import java.util.concurrent.Callable;

public class TestCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        // TODO 自动生成的方法存根
        int i=0;
        while(i<10){
            System.out.println(i);
            Thread.sleep(1000);
            i++;
        }
        return i;
    }

}

步骤2：创建一个类对象

TestCallable testCallable = new TestCallable();

步骤3：有Callable创建一个FutureTask对象

FutureTask<Integer> task = new FutureTask<Integer>(testCallable);

步骤4：由FutureTask对象创建一个Thread对象

Thread thread = new Thread(task);

步骤5：启动线程

thread.start();

FutureTask的get方法是返回Callable里的call返回的值，如果call方法里面是耗时任务，则get方法会阻塞主线程。

代码实现如下：
TestCallable类：

package com.yds.test;

import java.util.concurrent.Callable;

public class TestCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        // TODO 自动生成的方法存根
        int i=0;
        while(i<10){
            System.out.println(i);
            Thread.sleep(1000);
            i++;
        }
        return i;
    }

}

Test调用

package com.yds.test;

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

public class Test {

    public static void main(String[] args) {
        
        //1. 使用实现Runnable接口创建线程
//      Runnable testRunnable = new TestRunnable();
//      Thread testThread = new Thread(testRunnable);
//      testThread.start();
        
        
        //2. 使用Callable和Future创建线程
        TestCallable testCallable = new TestCallable();
        FutureTask<Integer> task = new FutureTask<Integer>(testCallable);
        Thread thread = new Thread(task);
        thread.start();     
    }

}

2.3 继承Thread类来创建线程

步骤1：定义一个继承Thread类的子类

public class TestThread extends Thread{
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        
    }
}

步骤2：构造子类的一个对象

TestThread testThread = new TestThread();

步骤3：启动线程

testThread.start();

代码示例如下：

TestThread类

package com.yds.test;

public class TestThread extends Thread{
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        int i = 0;
        while(i<10){
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            i++;
        }
    }
}