🦁 掌握基本概念

1. 什么是线程？

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）

2. 什么是主线程以及子线程？

当Java程序启动时，一个线程会立刻运行，该线程通常叫做程序的主线程（main thread），即main方法对应的线程，它是程序开始时就执行的。
在主线程中创建并启动的线程，一般称之为子线程。

3. 什么是串行？什么是并行？ 什么是并发?

1. 串行(serial)：一个CPU上，按顺序完成多个任务（先完成一个再接着下一个，类似栈里面的过程）。

2. 并行(parallelism)：指的是任务数小于等于cpu核数，即任务真的是一起执行的。

3. 并发(concurrency)：一个CPU采用时间片管理方式，交替的处理多个任务。一般是是任务数多于cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
   

🦁 线程的创建

一般两种方法：一个是继承Thread类（单继承）、一个是实现Runnerable接口（多实现）。

1. 通过继承Thread类实现多线程

• 在Java中负责实现线程功能的类是java.lang.Thread 类。
• 可以通过创建 Thread的实例来创建新的线程。
• 每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。
• 通过调用Thread类的start()方法来启动一个线程。

public class TestThread extends Thread { //自定义类继承Thread类
  //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);	//getName()方法是返回线程名称
        }
    }

    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.start();
    }
}

2. 通过Runnable接口实现多线程

public class TestThread2 implements Runnable { //自定义类实现Runnable接口；
  //run()方法里是线程体；
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
    //创建线程对象，把实现了Runnable接口的对象作为参数传入；
        Thread thread1 = new Thread(new TestThread2());
        thread1.start();//启动线程；
        Thread thread2 = new Thread(new TestThread2());
        thread2.start();
    }
}

🦁 线程执行流程

一个线程的一生需要经历五个状态：

开始——>就绪——>运行——>阻塞——>死亡

​ 详细变化如下👇

---

1. 新生态：在线程被new出来之后，拥有自己的内存空间则变成新生态。
2. 就绪状态：等待被cpu执行的状态，进入这种状态的情况有三种：

• 要么是新的线程被调用 start()方法

• 要么就是运行状态执行了yield()方法放弃了执行权回到就绪状态重新排队

• 要么就是线程阻塞解除，进入就绪状态。

3. 运行状态：线程终于可以执行自己run()方法里面的代码，直到运行结束或者其它因素才会终止运行。
4. 阻塞状态：线程因为某些因素终止执行，进入阻塞状态。（只有从运行状态才能进入阻塞状态）
5. 死亡状态：线程执行完毕或者被调用了destroy()等方法（赐死）。

🦁 常用的方法

1. 线程休眠

sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。sleep方法的参数为休眠的毫秒数。

Thread.sleep(5000);			//休眠5s

2. 线程让步

yield()方法：让当前正在运行的线程回到就绪状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。

tips：

• yield是一个静态的方法。
• 调用yield后，yield告诉当前线程把运行机会交给具有相同优先级的线程。
• yield不能保证，当前线程迅速从运行状态切换到就绪状态。
• yield只能是将当前线程从运行状态转换到就绪状态，而不能是等待或者阻塞状态。

Thread.yield();

3. 线程联合

使得线程由并行变串行

join()方法：当前线程邀请调用方法的线程优先执行，在调用方法的线程执行结束之前，当前线程不能再次执行。线程A在运行期间，可以调用线程B的join()方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能继续执行。
eg:
场景：实现爸爸让儿子买烟。

/**
 * 儿子买烟线程
 */
class SonThread implements Runnable{


  @Override
  public void run() {
    System.out.println("儿子出门买烟");
    System.out.println("儿子买烟需要10分钟");
    for(int i=0;i<10;i++){
      System.out.println("第"+i+"分钟");
      try {
        Thread.sleep(1000);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
     }
    System.out.println("儿子买烟回来了");
   }
}


/**
 * 爸爸抽烟线程
 */
class FatherThread implements Runnable{


  @Override
  public void run() {
    System.out.println("爸爸想抽烟，发现烟抽完了");
    System.out.println("爸爸让儿子去买一包红塔山");
    Thread t = new Thread(new SonThread());
    t.start();
    System.out.println("等待儿子买烟回来");
    try {
      t.join();
     } catch (InterruptedException e) {
      e.printStackTrace();
      System.out.println("爸爸出门找儿子");
      System.exit(1);
     }
    System.out.println("爸爸高兴的接过烟，并把零钱给了儿子");
   }
}


public class TestJoinDemo {
  public static void main(String[] args) {
    System.out.println("爸爸和儿子买烟的故事");
    Thread t = new Thread(new FatherThread());
    t.start();
   }
}

4. 获取线程名称

1. 如果是使用继承Thread类的方式，则可以直接调用this.getName()获取线程名称。

class GetName1 extends Thread{
  @Override
  public void run() {
    System.out.println(this.getName());
   }
}

2. 如果是实现Runnable接口实现多线程方式，则可以调用Thread.currentThread().getName()获取线程名称。

class GetName2 implements Runnable{
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName());
   }
}

5. 修改线程名称

1. 通过构造方法设置线程名称

class SetName1 extends Thread{
  public SetName1(String name){
    super(name);
   }
  @Override
  public void run() {
    System.out.println(this.getName());
   }
}


public class SetNameThread {
  public static void main(String[] args) {
    SetName1 setName1 = new SetName1("SetName1");
    setName1.start();
   }
}

2. 通过setName()方法设置线程名称。

class SetName2 implements Runnable{


  @Override
  public void run() {
    System.out.println(Thread.currentThread().getName());
   }
}
public class SetNameThread {
  public static void main(String[] args) {
    Thread thread = new Thread(new SetName2());
    thread.setName("SetName2");
    thread.start();
   }
}

6. 判断线程是否存活

isAlive()方法： 判断当前的线程是否处于活动状态。

活动状态是指线程已经启动且尚未终止，线程处于正在运行或准备开始运行的状态，就认为线程是存活的

class Alive implements Runnable{


  @Override
  public void run() {
    for(int i=0;i<4;i++){
      System.out.println(Thread.currentThread().getName()+" "+i);
      try {
        Thread.sleep(500);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
     }
   }
}


public class TestAliveThread {
  public static void main(String[] args) {
    Thread thread = new Thread(new Alive());
    thread.setName("Alive");
    thread.start();
    System.out.println(thread.getName()+" "+thread.isAlive());
    try {
      Thread.sleep(4000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    System.out.println(thread.getName()+" "+thread.isAlive());
   }
}

🦁 最后

这期的分享到这里，下期见！