Java实战开发篇-11 多线程

多线程

一、多线程中的几个概念

1.程序：静态的代码
2.进程：正在运行的一个程序 正在使用的QQ，Android Studio。进程用于管理所有的资源，不进行实际的任务
3.线程：完成具体任务，QQ运行起来就是线程（一个进程里面可以有多个线程）。运行QQ，聊天、视频、QQ游戏同时运行，这就是一个个线程
4.主线程：Java里面，main方法里面的代码就在主线程中运行。在手机里面，我们看到的主界面，就是一个主线程
5.子线程：除了主线程之外的线程

二、为什么使用多线程

在主线程里面，任务的执行是从上至下的，如果其中一个任务需要耗费大量时间。那么这个任务后面的任务就必须等这个任务结束后才能被执行，就会形成阻塞。这个时候就需要将这个任务放在另一个线程里面去执行（子线程）
*注：不管是主线程还是子线程都有自己独立的执行路径

三、如何开启一个线程

1.写一个类继承于Thread

步骤：
（1）创建类继承于Thread，具体执行的任务放在run（）里面
（2）创建类的对象
（3）调用start（）方法执行
注*线程的执行是通过抢占时间片来获取执行机会的，时间片是由操作系统来分配的
所以有多个线程的时候，每次执行的结果可能不一样

class TestThread extends Thread{
    //1.创建一个类继承于Thread
    //可以通过重写构造方法给子线程命名
    public TestThread(@NonNull String name) {
        super(name);
    }
    @Override
    //子类必须实现父类的run方法，这个线程执行的任务在run方法里面
    public void run() {
        System.out.println(getName());
        //也可以用Thread.currentThread（），获取当前线程的名字
        System.out.println("Hello World");
    }
}
public class MyClass {
    public static void main(String[] args){
         //2.创建具体的对象
        TestThread testThread = new TestThread("子线程");//给子线程命名
        //3.启动线程,不调用start无法启动线程
        testThread.start();
}
}
    public static void testRunnable(){
        //2.创建具体对象
        TestRunnable testRunnable = new TestRunnable();
        //3.创建一个Thread对象 让这个线程去执行testRunnable的任务
        Thread thread = new Thread(testRunnable);
        thread.start();
    }
}

2.写一个类实现Runnable接口

步骤：
（1）创建一个类实现Runnable接口，但它并不能分配线程
（2）创建一个该类的对象
（3）创建Thread类的对象来创建线程
（4）调用start方法开启线程

class TestRunnable implements Runnable{
    //1.创建一个类实现Runnable方法
    //这个类不能开启线程，也需要通过Thread来开启
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}
public class MyClass {
    public static void main(String[] args){
        //2.创建具体对象
        TestRunnable testRunnable = new TestRunnable();
        //3.创建一个Thread对象 让这个线程去执行testRunnable的任务
        Thread thread = new Thread(testRunnable);
        thread.start();
}
}

3.两种启动方式的对比

第一种创建方法简单一些，但是无法实现多继承
第二种灵活性更强，因为接口可以实现多继承

四、线程的生命周期

线程的5种形态

new创建状态->start就绪状态-><-抢到时间片,运行状态（失去时间片进入就绪状态）->run死亡状态
运行状态中，可能遇到阻塞状态

1.创建状态

new Thread（）

2.就绪状态

（1）调用start（）
（2）阻塞条件结束
（3）正在运行的线程时间片被其他线程所抢夺

3.运行状态

从就绪状态到运行状态是由操作系统进行，外部无法干预

4.死亡状态

（1）run方法结束
（2）手动让线程暂停 stop（不建议使用，通过其他方式暂停）

5.阻塞状态

阻塞状态分为3种，同步阻塞synchronized，等待阻塞wait，其他阻塞sleep，join

五、如何让一个线程结束

（1）使用stop()方法;（此方法不建议使用）
（2）写一个变量来标识线程结束

class TestThread extends Thread{
    boolean stop = true;
    @Override
   public void run() {
        while (stop) {
   System.out.println("子线程");
    }
    }
   public void terminated(){
        stop = false;
        }//写一个终止方法
}
public class MyClass {
    public static void main(String[] args){
    TestThread t = new TestThread();
    t.start();
    for(int i = 0;i<20;i++){
        if(i==10){
            t.terminated();
    }
    }
}
}

六、线程礼让和线程插队

线程礼让：yield（）
线程插队：join（）
礼让的线程会直接进入就绪状态，如果这个线程再次获得时间片，它还会执行，所以可能礼让失败

TestRunnable testRunnable = new TestRunnable();
    Thread t1 = new Thread(testRunnable,"子线程1");
     t1.start();
     for(int i = 0;i<100;i++){
     System.out.println("主线程");
     if(i == 20){
     Thread.yield();
  }
  }
public class MyClass {
    public static void main(String[] args){
    TestThread t = new TestThread();
    t.start();
}
}

插队同理，插队后的线程执行完后再执行原线程

七、多线程的利弊

1.优点

（1）提高执行的效率
（2）不会阻塞主线程

2.缺点

（1）多个线程操作同一个资源时，有可能会出错

class BuyTickets extends Thread{
  static int total = 10;
    @Override
    public void run() {
       for(int i = 1;i<11;i++){
       if (total == 0) {
       stop();
    }
    }
       total--;
       System.out.println("第"+(10-total)+"张票购成功");
    }
    }
}
public class MyClass {
    public static void main(String[] args){
       BuyTickets Passenger1 = new BuyTickets();
       BuyTickets Passenger2 = new BuyTickets();
       BuyTickets Passenger3 = new BuyTickets();
       Passenger1.start();
       Passenger2.start();
       Passenger3.start();
    }
}

3.克服缺点的办法

（1）Lock锁，代码块必须使用同一把锁
（2）2.synchronized锁

class BuyTickets extends Thread{
    Object object = new Object();//创建一个临时对象
  static int total = 10;
    @Override
    public void run() {
      for(int i = 1;i<11;i++){
      synchronized (object) {
      if (total == 0) {
      stop();
    }
    }
      total--;
      System.out.println("第"+(10-total)+"张票购成功");
    }
    }
}
public class MyClass {
    public static void main(String[] args){
       BuyTickets Passenger1 = new BuyTickets();
       BuyTickets Passenger2 = new BuyTickets();
       BuyTickets Passenger3 = new BuyTickets();
       Passenger1.start();
       Passenger2.start();
       Passenger3.start();
    }
}

*注：锁的对象必须相同，每一个对象都维护一把锁
不管是锁代码块还是锁方法，尽量让锁的范围变小

八、线程间的通信

1.实现线程间通信的三个方法

（1）wait（）让某个线程等待
（2）notify（）唤醒某个线程
（3）notifyAll（）唤醒所有线程
*注：这三个方法必须由同步监视器（必须被Lock或synchronized包装的代码块）来调用

public class MyClass {
    static intersection section = new intersection();
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                section.printnum();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                section.printlet();
            }
        }).start();
    }
}//匿名对象和匿名内部类快速创建对象和调用方法
class intersection{
    int number = 1;
    char letter = 'a';
    int state = 1;//通过变化state的值来改变线程
    public synchronized void printnum(){
    while(true){
       if(state != 1){
       try {
       this.wait();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  }
    System.out.println(number);
    number++;
      if(number == 27){
      break;
  }
      state = 2;
      this.notify();
  }
  }
  public synchronized void printlet(){
        while(true){
        if(state != 2){
        try {
        this.wait();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
   }
    System.out.println(letter);
    letter++;
     if(letter == ('z'+1)){
     break;
    }
     state = 1;
     this.notify();
    }
    }
}