Java创建线程的几种方式

Java创建线程的几种方式 继承Thread类

1. 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
2. 创建Thread子类的实例，即创建了线程对象。
3. 调用线程对象的start()方法来启动该线程。

public class CreatThreadDemo1 extends Thread {
  
  public CreatThreadDemo1(String name) {
    super(name);
  }

  @Override
  public void run() {
    if (!interrupted()) {
      for (int i = 1; i <= 10; i++) {
        System.out.println(getName() + "跑了" + i + "米");
        try {
          Thread.sleep(200);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }

  public static void main(String[] args) {
    CreatThreadDemo1 turtle = new CreatThreadDemo1("龟");
    CreatThreadDemo1 rabbit = new CreatThreadDemo1("兔");
    turtle.start();
    rabbit.start();

    // 中断第一个线程
    rabbit.interrupt();
  }
}

小贴士

1. getName()：返回调用该方法的线程的名；

2. Thread.sleep(200)：线程休息200ms；

3. interrupt()：中断线程。终止线程不允许用stop方法，该方法不会施放占用的资源。所以我们在设计程序的时候，要按照中断线程的思维去设计，就像上

   面的代码一样；

实现Runnable接口

1. 定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体同样是该线程的线程执行体；
2. 创建 Runnable 实现类的实例，并依此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象；
3. 调用线程对象的 start() 方法来启动该线程；

public class CreatThreadDemo2 implements Runnable {

  @Override
  public void run() {
    for (int i = 1; i <= 10; i++) {
      System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static void main(String[] args) {
    // 将线程任务传给线程对象
    Thread turtle = new Thread(new CreatThreadDemo2());
    turtle.setName("龟");
    Thread rabbit = new Thread(new CreatThreadDemo2());
    rabbit.setName("兔");
    // 启动线程
    turtle.start();
    rabbit.start();
  }
}

匿名内部类创建线程对象

@SuppressWarnings("all")
public class CreatThreadDemo3 extends Thread {
  public static void main(String[] args) {
    // 创建无参线程对象
    new Thread() {
      @Override
      public void run() {
        System.out.println("无参线程对象 - 线程执行了...");
      }
    }.start();
    // 创建带线程任务的线程对象
    new Thread(
            new Runnable() {
              @Override
              public void run() {
                System.out.println("带线程任务的线程对象 - 线程执行了...");
              }
            })
        .start();
    // 创建带线程任务并且重写run方法的线程对象
    new Thread(
        new Runnable() {
          @Override
          public void run() {
            System.out.println("runnable run 线程执行了...");
          }
        }) {
      @Override
      public void run() {
        System.out.println("override run 线程执行了...");
      }
    }.start();
  }
}

小贴士

创建带线程任务并且重写 run 方法的线程对象中，为什么只运行了 Thread 的 run 方法？因为 Thread 实现了 Runnable 接口，而 Runnable 接口里有一个 run 方法。所以，我们最终调用的重写的方法应该是 Thread 类的 run 方法。而不是 Runnable 接口的 run 方法。

创建带返回值的线程

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


@SuppressWarnings("all")
public class CreatThreadDemo4 implements Callable {
  public static void main(String[] args) throws Exception {
    CreatThreadDemo4 demo4 = new CreatThreadDemo4();
    FutureTask task = new FutureTask(demo4);

    // FutureTask最 终实现的是runnable接口
    Thread thread = new Thread(task);
    thread.start();
    System.out.println("我可以在这里做点别的业务逻辑...因为FutureTask是提前完成任务");

    // 拿出线程执行的返回值
    Integer result = task.get();
    System.out.println("线程中运算的结果为:" + result);
  }

  
  @Override
  public Object call() throws Exception {
    System.out.println("业务逻辑计算中...");
    Thread.sleep(3000);
    return 1 + 1;
  }
}

Callable 接口

返回指定泛型的 call 方法。然后调用 FutureTask 对象的 get 方法得道 call 方法的返回值。

package java.util.concurrent;


@FunctionalInterface
public interface Callable {
    
    V call() throws Exception;
}

定时器Timer

import java.util.Timer;
import java.util.TimerTask;


@SuppressWarnings("all")
public class CreatThreadDemo5 {
  public static void main(String[] args) {
    Timer timer = new Timer();
    timer.schedule(
        new TimerTask() {
          @Override
          public void run() {
            System.out.println("定时器线程执行了...");
          }
        },
        0,
        1000);
    // 延迟0，周期1s
  }
}

线程池

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


@SuppressWarnings("all")
public class CreatThreadDemo6 {
  public static void main(String[] args) {
    // 创建一个具有10个线程的线程池
    ExecutorService threadPool = Executors.newFixedThreadPool(10);

    for (int i = 0; i < 10; i++) {
      threadPool.execute(
          new Runnable() {
            @Override
            public void run() {
              System.out.println(Thread.currentThread().getName() + "线程执行了...");
            }
          });
    }

    // 销毁线程池
    threadPool.shutdown();
  }
}