java 创建线程的四种方式

1、继承Thread类方式

这种方式适用于执行特定任务，并且需要获取处理后的数据的场景。

举例：一个用于累加数组内数据的和的线程。

public class AdditionThread extends Thread {
 private int sum = 0;
 private int[] nums;
​
 public AdditionThread(int[] nums, String threadName) {
  super(threadName);
  this.nums = nums;
 }
​
 @Override
 public void run() {
  for (int num : nums) {
   sum += num;
  }
 }
​
 public int getSum() {
  return sum;
 }
}

调用方式：

public class Main {
 public static void main(String[] args) throws InterruptedException {
  int[] nums = {10, 12, 15, 200, 100};
  AdditionThread thread = new AdditionThread(nums, "AdditionThread");
  thread.start();
  thread.join();
​
  System.out.println("sum=" + thread.getSum());
 }
}

2、Runnable 接口方式

定义一个实现Runnable接口的类，或者直接创建一个匿名内部类，并覆盖 run() 方法。最后作为参数传给Thread的构造函数。

public class Main {
 public static void main(String[] args) {
  // 自定义的 Runnable
  Runnable runnable = new MyRunnable();
  Thread thread = new Thread(runnable, "Runnable-Thread");
  thread.start();
​
  // 自定义匿名内部类
  new Thread(() -> {
   System.out.println("Inner class");
  }).start();
 }
​
 static class MyRunnable implements Runnable {
  @Override
  public void run() {
   System.out.println("MyRunnable");
  }
 }
}

3、 Callable 接口方式

Callable 接口与 Runnable 接口的区别：

（1）Callable 的方法为call()，Runnable的方法为run()。

（2）Callable 的方法由返回值，Runnable 没有。

（3）Callable 的方法声明的Exception，Runnable的没有。

public class Main {
 public static void main(String[] args) {
  MyCallable myCallable = new MyCallable();
  FutureTask<String> task = new FutureTask<>(myCallable);
  Thread thread = new Thread(task, "FutureTask");
  thread.start();
  try {
   // 通过get方法获取返回值
   String result = task.get();
   System.out.println(result);
  } catch (InterruptedException | ExecutionException e) {
   e.printStackTrace();
  }
 }
​
 static class MyCallable implements Callable<String> {
  @Override
  public String call() throws Exception {
   // 模拟超时操作
   Thread.sleep(1000);
   return "OK";
  }
 }
}

4、线程池方式

我们可以通过 ThreadPoolExecutor 类的构造函数来创建线程池，也可以通过Executors工厂方法来创建，如

// 创建固定线程数的线程池
Executors.newFixedThreadPool(); 
// 创建只有一个核心线程的线程池
Executors.newSingleThreadExecutor();
// 创建一个没有核心线程，但可以缓存线程的线程池
Executors.newCachedThreadPool();
// 创建一个适用于执行定时任务的线程池
Executors.newScheduledThreadPool();

在创建线程池时，最好传入 ThreadFactory 参数，指定线程池所创建线程的名称。这样有利于分析定位可能存在的问题。

public class Main {
 private static final ExecutorService SERVICE =
  Executors.newFixedThreadPool(5, new BasicThreadFactory("My-Thread"));
​
 public static void main(String[] args) {
  // 打印线程的名字
  System.out.println("main thread name:" + Thread.currentThread().getName());
  SERVICE.execute(() -> {
   System.out.println("Hello thread pool.");
   // 打印线程池里的线程的名字
   System.out.println("thread name:" + Thread.currentThread().getName());
  });
 }
​
 static class BasicThreadFactory implements ThreadFactory {
  private final AtomicInteger threadNumber = new AtomicInteger(0);
  private final String basicName;
​
  public BasicThreadFactory(String basicName) {
   this.basicName = basicName;
  }
​
  @Override
  public Thread newThread(Runnable runnable) {
   Thread thread = new Thread(runnable);
   String name = this.basicName + "-" + threadNumber.incrementAndGet();
   thread.setName(name);
   return thread;
  }
 }
}

以上就是java 创建线程的四种方式的详细内容，更多关于java 创建线程的资料请关注易盾网络其它相关文章！