多线程编程是一个优秀程序员必备的能力，多线程是解决项目中性能问题的一个重要技术利器，现在的计算机基本都是多核处理器，使用多线程编程可以大大提高处理器的使用效率，提升系统的吞吐率。

1
线程的创建

01、方式一：继承Thread类

继承Thread类创建多线程的步骤：

1、定义子类，继承Thread类；

2、子类中重写Thread类中的run方法；

3、创建Thread子类对象，也就是创建线程对象；

4、调用线程对象的start方法启动线程。

示例：使用继承Thread类的方式创建一个线程，实现从1输出到5。

//定义线程类Task继承Thread类
public class Task extends Thread {

  // 子类中重写Thread类中的run方法
  public void run() {
    for (int i = 1; i <= 5; i++) {
      System.out.println("线程输出：" + i);
    }
  }
}

//测试类
public class TaskTest {

  public static void main(String[] args) {
    // 创建线程对象
    Task task = new Task();
    // 调用线程对象的start方法启动线程
    task.start();
  }
}

程序运行结果：
线程输出：1
线程输出：2
线程输出：3
线程输出：4
线程输出：5

02、******方式二：实现Runnable接口******

实现Runnable接口创建多线程的步骤：

1、定义子类，实现Runnable接口；

2、子类中重写Runnable接口中的run方法；

3、创建Runnable接口的子类对象；

4、通过Thread类的构造器创建线程对象；

5、调用Thread类的start方法启动线程。

示例：使用实现Runnable接口的方式创建一个线程，实现从1输出到5。

//定义线程类Task1实现Runnable接口
public class Task1 implements Runnable {

  @Override
  //子类中重写Runnable接口中的run方法
  public void run() {
    for (int i = 1; i <= 5; i++) {
      System.out.println("线程输出：" + i);
    }
  }

}

//测试类
public class Task1Test {

  public static void main(String[] args) {
    // 创建Runnable接口的子类对象
    Task1 task = new Task1();
    // 通过Thread类创建线程对象
    // 将Runnable接口的子类对象作为参数传递给Thread类的构造方法
    Thread taskThread = new Thread(task);
    // 调用Thread类的start方法启动线程
    taskThread.start();
  }
}

程序运行结果：
线程输出：1
线程输出：2
线程输出：3
线程输出：4
线程输出：5

03、方式三：通过Callable和Future创建线程

通过Callable和Future创建多线程的步骤：

1、定义子类，实现Callable接口，带有返回值；

2、子类中重写Callable接口中的call方法；

3、创建Callable接口的子类对象；

4、使用FutureTask类来包装Callable对象

5、通过Thread类的构造器创建线程对象，使用FutureTask象作为Thread对象的 target创建；

6、调用Thread类的start方法启动线程；

7、调用FutureTask对象的get方法来获得线程执行结束后的返回值；

示例：使用Callable和Future的方式创建一个线程，实现从1输出到5。

import java.util.concurrent.Callable;

//定义线程类Task2实现Callable接口，带有Integer返回值
public class Task2 implements Callable<Integer> {

  @Override
  // 子类中重写Callable接口中的call方法
  public Integer call() throws Exception {
    Integer num = 0;
    for (int i = 1; i <= 5; i++) {
      System.out.println("线程输出：" + i);
      num = i;
    }
    return num;
  }
}

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

// 测试类
public class Task2Test {

  public static void main(String[] args) {
    // 创建Callable接口的子类对象
    Callable<Integer> task2 = new Task2();
    // 使用FutureTask类来包装Callable对象
    FutureTask<Integer> task = new FutureTask<Integer>(task2);
    // 通过Thread类的构造器创建线程对象
    // 使用FutureTask象作为Thread对象的 target创建
    Thread taskThread = new Thread(task);
    // 调用Thread类的start方法启动线程
    taskThread.start();
    try {
      // 输出线程执行后的返回值
      System.out.println("线程执行后的返回值：" + task.get());
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }
}

程序运行结果：
线程输出：1
线程输出：2
线程输出：3
线程输出：4
线程输出：5
线程执行后的返回值：5

2
设置线程名称

01、获取线程的名称

通过Thread.currentThread().getName()来获取线程名称。

public class Task3 extends Thread {

  public void run() {
    for (int i = 1; i <= 5; i++) {
      System.out.println(Thread.currentThread().getName() + "：" + i);
    }
  }
}

// 测试类
public class Task3Test {

  public static void main(String[] args) {
    Task3 task = new Task3();
    task.start();
  }
}

程序运行结果：
Thread-0：1
Thread-0：2
Thread-0：3
Thread-0：4
Thread-0：5

从上面的运行结果可以看出，在没有指定线程名称的时候，线程的名称默认是：Thread-0。

****02、设置线程的名称****

通过Thread类的构造函数，可以设置线程的名称。

示例1：通过继承Thread类创建线程类Car，创建3辆宝马车、4辆奔驰车。

public class Car extends Thread {

  private int number;

  public Car(String name, int number) {
    super(name); // 通过父类的构造函数设置线程的名称
    this.number = number;
  }

  public void run() {
    for (int i = 1; i <= number; i++) {
      System.out.println(Thread.currentThread().getName() + "启动，number="
          + i);
    }
  }
}

// 测试类
public class CarTest {

  public static void main(String[] args) {
    Car bmw = new Car("宝马", 3);
    Car benz = new Car("奔驰", 4);
    bmw.start();
    benz.start();
  }
}

程序运行结果（程序运行的结果可能有多个）：
奔驰启动，number=1
宝马启动，number=1
奔驰启动，number=2
宝马启动，number=2
宝马启动，number=3
奔驰启动，number=3
奔驰启动，number=4

以上程序创建了两个Car的线程对象，程序每次执行的结果可能不一样，这就是多线程的作用，运行结果取决于哪个线程抢到了CPU。

示例2：通过实现Runnable接口创建线程类Dog，哈士奇吼叫3声、萨摩耶吼叫4声。

public class Dog implements Runnable {

  private int number; // 吼叫次数

  public Dog(int number) {
    this.number = number;
  }

  @Override
  public void run() {
    for (int i = 1; i <= number; i++) {
      System.out.println(Thread.currentThread().getName() + "吼叫，i=" + i);
    }
  }
}

// 测试类
public class DogTest {

  public static void main(String[] args) {
    Dog dog1 = new Dog(3);
    Dog dog2 = new Dog(4);
    // 通过Thread类的构造函数设置线程名称
    Thread t1 = new Thread(dog1, "哈士奇");
    Thread t2 = new Thread(dog2, "萨摩耶");
    t1.start();
    t2.start();
  }
}

程序运行结果（程序运行的结果可能有多个）：
萨摩耶吼叫，number=1
哈士奇吼叫，number=1
哈士奇吼叫，number=2
哈士奇吼叫，number=3
萨摩耶吼叫，number=2
萨摩耶吼叫，number=3
萨摩耶吼叫，number=4

以上程序创建了两个Dog的线程对象，通过Thread类的构造函数设置线程名称。

3
线程的启动和停止

****01、线程的启动需要调用Thread的start方法，而不是调用对象的run方法****

示例：我们看下调用线程对象的run方法和调用Thread对象的start方法的区别，演示的线程类使用上面的Car类。

// 调用线程对象的run方法
public class CarTest {

  public static void main(String[] args) {
    Car bmw = new Car("宝马", 3);
    Car benz = new Car("奔驰", 4);
    bmw.run();
    benz.run();
  }
}

程序运行结果：
main启动，number=1
main启动，number=2
main启动，number=3
main启动，number=1
main启动，number=2
main启动，number=3
main启动，number=4

// 调用线程对象的start方法
public class CarTest {

  public static void main(String[] args) {
    Car bmw = new Car("宝马", 3);
    Car benz = new Car("奔驰", 4);
    bmw.start();
    benz.start();
  }
}

程序运行结果（程序运行的结果可能有多个）：
宝马启动，number=1
奔驰启动，number=1
宝马启动，number=2
奔驰启动，number=2
宝马启动，number=3
奔驰启动，number=3
奔驰启动，number=4

从上面程序的运行结果可以看出，调用run方法其实没有启动多线程执行，相当于执行了对象的普通方法，线程是主线程（main）；而真正能启动多线程的则是调用Thread类对象的start方法。

****02、************调用Thread类对象的start方法两次，是否可以启动两个线程********

答案是不可以，因为start方法执行时，会判断线程的状态，当线程启动后再次调用start方法则会抛出IllegalThreadStateException异常，这是运行时异常，在代码编写的时候调用两次start方法，编译是没有问题的。

示例1：用同一个线程对象调用两次start方法，演示的线程类使用上面的Car类。

public class CarTest {

  public static void main(String[] args) {
    Car bmw = new Car("宝马", 3);
    bmw.start();
    bmw.start();  // 运行时异常，不应该这么调用
  }
}

程序运行结果：
Exception in thread "main" 宝马启动，number=1
宝马启动，number=2
宝马启动，number=3
java.lang.IllegalThreadStateException
  at java.lang.Thread.start(Unknown Source)
  at testThread.CarTest.main(CarTest.java:8)

示例2：调用多个Thread子类对象的start方法是创建多个线程的正确方式，演示的线程类使用上面的Car类和Dog类。

// 继承Thread类的线程创建2个线程的方式
public class CarTest {

  public static void main(String[] args) {
    Car bmw = new Car("宝马", 3);
    Car benz = new Car("奔驰", 4);
    bmw.start();
    benz.start();
  }
}

// 实现实现Runnable接口的线程创建2个线程的方式
public class DogTest {

  public static void main(String[] args) {
    Dog dog1 = new Dog(3);
    Dog dog2 = new Dog(4);
    // 通过Thread类的构造函数设置线程名称
    Thread t1 = new Thread(dog1, "哈士奇");
    Thread t2 = new Thread(dog2, "萨摩耶");
    t1.start();
    t2.start();
  }
}

大家不要觉得这个知识点没什么，我见过工作三年多的程序员写代码，想启动两个线程，就用了同一个线程对象调用两次start方法。

****03、线程的停止****

我们可以通过一个布尔变量来控制线程的停止。

示例：通过改变布尔变量的值使线程停止

public class StopThread implements Runnable {
  private boolean flag = true; // 控制线程停止的变量，初始为true
  private int i = 0;

  @Override
  public void run() {
    while (this.flag) {  // flag为true时，一直输出i的值
      System.out.println(i++);
    }
  }

  void stop() {
    this.flag = false;  // 修改布尔变量的值为false，让while循环停止
  }
}

// 测试类
public class StopThreadTest {

  public static void main(String[] args) throws InterruptedException {
    StopThread mt = new StopThread();
    new Thread(mt).start();
    Thread.sleep(1); // 主线程休眠，可以更好的观察子线程停止的效果
    mt.stop();
  }
}

程序运行结果：
0
1

从上面的程序运行结果来看，线程启动后，通过stop方法修改布尔变量的值为false，从而达到线程run方法里while循环的退出，进而使线程停止运行。

以上内容对多线程的基本知识进行了讲解，希望大家可以熟练掌握。