实现多线程的方式

1. 继承 Thread 类，重写 run 方法，调用 start 方法；
2. 实现 Runnable 接口，重写 run 方法，调用 start 方法；
3. 实现 Callable接口，重写 call 方法，并使用 FutureTask 配合完成有返回值多线程 ；
4. 基于线程池

   1.继承 Thread 类

   核心类 ```java package top.simba1949.multi.thread;

/**

• @author SIMBA1949
• @date 2020/10/19 23:13 / public class MultiThreadOne extends Thread{ /*
  • 实现多线程的第一种方式，extend Thread，重写 run 方法 */ @Override public void run() { Thread thread = Thread.currentThread(); System.out.println(“threadName=” + thread.getName()); } } 调用方式java package top.simba1949;

import top.simba1949.multi.thread.MultiThreadOne;

/**

• @author SIMBA1949
• @date 2020/10/19 23:22 */ public class Application { public static void main(String[] args) {

   MultiThreadOne multiThreadOne = new MultiThreadOne();
   multiThreadOne.start();

  } } ```

  2.实现 Runnable 接口

  基础实现

  核心类 ```java package top.simba1949.multi.thread;

/**

• @author SIMBA1949
• @date 2020/10/19 23:25 / public class MultiThreadTwo implements Runnable{ /*
  • 实现多线程的第二种方式，实现 Runnable，重写 run 方法 */ @Override public void run() { Thread thread = Thread.currentThread(); System.out.println(“threadName=” + thread.getName()); } } 调用方式java package top.simba1949;

import top.simba1949.multi.thread.MultiThreadTwo;

/**

• @author SIMBA1949
• @date 2020/10/19 23:22 */ public class Application { public static void main(String[] args) {

   MultiThreadTwo multiThreadTwo = new MultiThreadTwo();
   Thread thread = new Thread(multiThreadTwo);
   thread.start();

  } } ```

  匿名内部类

  核心类与调用方式 ```java package top.simba1949;

/**

• @author SIMBA1949
• @date 2020/10/19 23:22 */ public class Application { public static void main(String[] args) {

   // 使用匿名内部类
   new Thread(new Runnable() {
       @Override
       public void run() {
           Thread innerThread = Thread.currentThread();
           System.out.println("threadName=" + innerThread.getName());
       }
   }).start();

  } } ```

  lambda表达式

  核心类与调用方式 ```java package top.simba1949;

/**

• @author SIMBA1949
• @date 2020/10/19 23:22 */ public class Application { public static void main(String[] args) {

   // 使用 lambda 表达式
   new Thread(() -> {
       Thread innerThread = Thread.currentThread();
       System.out.println("threadName=" + innerThread.getName());
   }).start();

  } } ```

  3.实现 Callable接口

  核心类 ```java package top.simba1949.multi.thread;

import java.util.concurrent.Callable;

/**

• @author SIMBA1949
• @date 2020/10/19 23:44 */ public class MultiThreadThree implements Callable { @Override public String call() throws Exception {

   Thread thread = Thread.currentThread();
   System.out.println("threadName=" + thread.getName());
   return thread.getName();

  } } 调用方式java package top.simba1949;

import top.simba1949.multi.thread.MultiThreadThree;

import java.util.concurrent.FutureTask;

/**

• @author SIMBA1949
• @date 2020/10/19 23:22 */ public class Application { public static void main(String[] args) throws Exception {

   // 创建自定义线程
   MultiThreadThree multiThreadThree = new MultiThreadThree();
   // FutureTask接收自定义线程
   FutureTask<String> futureTask = new FutureTask<>(multiThreadThree);
   //  调用 thread.start 启动线程
   new Thread(futureTask).start();
   // 获取线程的返回结果
   String result = futureTask.get();
   System.out.println(result);

  } } ```

  4.基于线程池

  ```java package top.simba1949;

import java.util.concurrent.*;

/**

• @author anthony
• @date 2022/1/26 */ public class App { public static void main(String[] args) {

   // 创建线程池
   ExecutorService threadPool = Executors.newFixedThreadPool(10);
   while (true) {
       threadPool.execute(new Runnable() {
           @Override
           public void run() {
               System.out.println(Thread.currentThread().getName() + " is running ..");
               try {
                   Thread.sleep(3000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       });
   }

  } } ```