关于后端:创建线程的几种方式

在 Java 中，能够应用以下几种形式来创立线程：

1、继承 Thread 类：能够创立一个类，继承 java.lang.Thread 类，并重写 run() 办法来定义线程代码。而后，能够创立一个新的 Thread 对象，并调用 start() 办法来启动线程

class MyThread extends Thread {public void run() {// 线程代码}
}

// 创立新线程并启动
MyThread thread = new MyThread();
thread.start();

2、实现 Runnable 接口：能够创立一个类，实现 java.lang.Runnable 接口，并实现 run() 办法来定义线程代码。而后，能够创立一个新的 Thread 对象，并将 Runnable 实例传递给 Thread 构造函数。

class MyRunnable implements Runnable {public void run() {// 线程代码}
}

// 创立新线程并启动
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

3、实现 Callable 接口：能够创立一个类，实现 java.util.concurrent.Callable 接口，并实现 call 办法来定义线程代码。而后，能够创立一个新的 Thread 对象，并将 Runnable 实例传递给 Thread 构造函数。

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {sum += i;}
        return sum;
    }
}

public class Main {public static void main(String[] args) {
        // 创立线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交可调用工作
        Future<Integer> future = executor.submit(new MyCallable());

        try {
            // 期待计算实现并获取后果
            int result = future.get();
            System.out.println("后果：" + result);
        } catch (InterruptedException e) {e.printStackTrace();
        } catch (ExecutionException e) {e.printStackTrace();
        }

        // 敞开线程池
        executor.shutdown();}
}

4、应用匿名外部类：能够应用匿名外部类来创立线程，防止创立多个类。能够在 Thread 构造函数中传递一个 Runnable 对象的匿名外部类来定义线程代码。

// 创立新线程并启动
Thread thread = new Thread(new Runnable() {public void run() {// 线程代码}
});
thread.start();

5、应用 Lambda 表达式：能够应用 Lambda 表达式来创立线程，防止创立多个类。能够在 Thread 构造函数中传递一个 Runnable 对象的 Lambda 表达式来定义线程代码。

// 创立新线程并启动
Thread thread = new Thread(() -> {// 线程代码});
thread.start();