如何创建、启动 Java 线程

参考答案

Java 中创建线程的4种常见方式：

一、重写 Thread 类的 run() 方法

有两种表现形式：

1.   new Thread 对象匿名重写 run() 方法

public class TestNewThread {
    
    public static void main(String[] args) {
        //创建线程 t, 重写 run() 方法
        new Thread("t") {
            @Override
            public void run() {
                for (int i = 0; i <3; i++) {
                    System.out.println("thread t > " + i);
                }
            }
        }.start();
    }

}

结果：

thread t > 0
thread t > 1
thread t > 2

2.  继承 Thread 对象，重写 run() 方法

public class TestExtendsThread {
    
    public static void main(String[] args) {
        new ThreadExt().start();
    }

}

//ThreadExt 继承 Thread，重写 run() 方法
class ThreadExt extends Thread {

    @Override
    public void run() {
        for (int i = 0; i <3; i++) {
            System.out.println("thread t > " + i);
        }
    }
    
}

结果：

thread t > 0
thread t > 1
thread t > 2

二、实现 Runnable 接口，重写 run() 方法。

有两种表现形式：

1.   new Runnable 对象，匿名重写 run() 方法

public class TestNewRunnable {

    public static void main(String[] args) {
        newRunnable();
    }
    
    public static void newRunnable() {
        //创建线程 t1, 重写 run() 方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <3; i++) {
                    System.out.println("thread t1 > " + i);
                    try {
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
                
        //创建线程 t2, lambda 表达式设置线程的执行代码
        //JDK 1.8 开始支持 lambda 表达式
        new Thread(() -> {
            for (int i = 0; i <3; i++) {
                System.out.println("thread t2 > " + i);
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2").start();
    }
}

结果：

thread t1 > 0
thread t2 > 0
thread t1 > 1
thread t2 > 1
thread t1 > 2
thread t2 > 2

2.  实现 Runnable 接口，重写 run() 方法

public class TestImplRunnable {

    public static void main(String[] args) {
        new Thread(new RunnableImpl()).start();
    }
}

///RunnableImpl 实现 Runnalbe 接口，重写 run() 方法
class RunnableImpl implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <3; i++) {
            System.out.println("thread t > " + i);
        }
    }
    
}

结果：

thread t > 0
thread t > 1
thread t > 2

三、实现 Callable 接口，使用 FutureTask 类创建线程

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

public class TestCreateThreadByFutureTask {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //通过构造 FutureTask(Callable callable) 构造函数，创建 FutureTask，匿名实现接口 Callable 接口
        FutureTask<String> ft = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "javamianshi.com";
            }
        });
        
        //Lambda 方式实现
//        FutureTask<String> ft = new FutureTask<String>(() ->  "javamianshi.com");
        
        new Thread(ft).start();
        System.out.println("执行结果：" + ft.get());
    }
}

结果：

执行结果：javamianshi.com

四、使用线程池创建、启动线程

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCreateThreadByThreadPool {

    public static void main(String[] args) {
        // 使用工具类 Executors 创建单线程线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        //提交执行任务
        singleThreadExecutor.submit(() -> {System.out.println("单线程线程池执行任务");});
        //关闭线程池
        singleThreadExecutor.shutdown();
    }
}

结果：

单线程线程池执行任务

以上，是Java面试题【如何创建、启动 Java 线程】的参考答案。

输出，是最好的学习方法。

欢迎在评论区留下你的问题、笔记或知识点补充~

—end—