• 创建线程的两种方式

      1. 1.继承Thread类
      2. 2.实现Runable接口

    • 继承Thread类代码 ```java public class Thread01 { public static void main(String[] args) {

      1.   // 创建cat对象，可以当作线程使用
      2.   Cat cat = new Cat();
      3.   /*
      4.   * 源码解读：
      5.   * (1)
      6.   * public synchronized void start() {
      7.   *   start0();
      8.   * }
      9.   * (2)
      10.   * start0(),是本地方法，是JVM调用，底层是C/C++实现
      11.   * 真正实现多线程的效果，是start0()，而不是run
      12.   * 
      13.   * start()方法调用start0()方法后，该线程并不一定会立马执行，
      14.   * 只是将线程变成了可运行状态，具体什么时候运行，取决于CPU，由CPU统一调度
      15.   * 
      16.   * */
      17.   cat.start();    // 启动线程 -> 最终会执行cat的run方法
      18.   // cat.run();  // run方法就是一个普通的方法，并没有真正的启动一个线程，把run方法执行完毕，才继续往下进行
      19.   // 说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
      20.   // 这时，主线程和子线程是交替执行的（并发）

      } }

    /*

    • 1.当一个类继承了Thread类，该类就可以当作线程使用
    • 2.我们会重写run方法，写上自己的业务代码
    • 3.run Thread类实现了Runable接口的run方法 @Override public void run() {
      1.   if (target != null) {
      2.       target.run();
      3.   }
      }
    • */ class Cat extends Thread { int times = 0; @Override public void run() {
      1.   while (true) {
      2.       // 输出结果
      3.       System.out.println("喵喵，这是小猫咪" + (++times));
      4.       // 让该线程休眠
      5.       try {
      6.           Thread.sleep(1000);
      7.       } catch (InterruptedException e) {
      8.           e.printStackTrace();
      9.       }
      10.       if (times == 8) {
      11.           break;
      12.       }
      13.   }
      } }
    2. - 实现Runable接口

    1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类 的方法来创建线程显然不可能了 2.java设计者们提供了另外一个方式创建线程，就是通过实现Runable接口来创建线程

    2. - 继承Thread类 和 实现Runable的区别

    1.从java的设计来看，通过继承Thread或者实现Runable接口来创建线程本质上没有区别， 从jdk帮助文档我们可以看到Thread类本身就实现了Runable接口 start() -> start0() 2.实现Runable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制, 建议使用Runable接口

    2. - 线程终止

    1.当线程完成任务后，会自动退出 2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

    1. ```java
    2. public class Thread03 {
    3.     public static void main(String[] args) throws InterruptedException {
    4.         T t = new T();
    5.         t.start();
    7.         /*
    8.         * 如果希望main线程去控制t线程的终止，必须可以修改loop
    9.         * 让t退出run方法，从而终止t1线程 -> 通知方式
    10.         * 让主线程休眠10s，再通知t1线程退出
    11.         * */
    12.         System.out.println("main线程休眠10s");
    13.         Thread.sleep(10 * 1000);
    14.         t.setLoop(false);
    15.     }
    16. }
    18. class T extends Thread { // 通过实现runable接口，开发线程
    19.     private int count = 0;
    20.     // 设置一个控制变量
    21.     private boolean loop = true;
    22.     @Override
    23.     public void run() {
    24.         while (loop) {
    25.             System.out.println( (++count) + Thread.currentThread().getName());
    27.             //休眠1s
    28.             try {
    29.                 Thread.sleep(1000);
    30.             } catch (InterruptedException e) {
    31.                 e.printStackTrace();
    32.             }
    34.         }
    35.     }
    37.     public void setLoop(boolean loop) {
    38.         this.loop = loop;
    39.     }
    40. }

    • 线程常用方法 | setName | 设置线程名称，使之与参数name相同 | | —- | —- | | getName | 返回该线程的名称 | | start | 使该线程开始执行；java虚拟机底层调用该线程的start()方法 | | run | 调用线程对象run方法 | | setPriority | 更改线程的优先级 | | getPriority | 获取线程的优先级 | | sleep | 在指定的毫秒数内让正在执行的线程休眠 | | interrupt | 中断线程 | | 注意事项和细节：
      1.start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
      2.线程优先级的范围（1、5、10）
      3.interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
      4.sleep：线程的静止方法，使当前线程休眠 | | | yield | 线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功 | | join | 线程的插队。插队的线程一旦插队成功，则肯定限制性完插入的线程所有的任务 |

    • 用户线程和守护线程

      1. 1.用户线程：也叫做工作线程，当线程的任务执行完或通知方式结束
      2. 2.守护线程：一般是为了工作线程服务的，当所有的用户线程结束，守护线程自动结束
      3. 3.常见的守护线程：垃圾回收机制

    • 线程的生命周期 | NEW | 尚未启动的线程处于此状态 | | —- | —- | | RUNNABLE | 在java虚拟机中执行的线程处于此状态 | | BLOCKED | 被阻塞等待监视器锁定的线程处于此状态 | | WATTING | 正在等待另一个线程执行特定动作的线程处于此状态 | | TIMED_WAITING | 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态 | | TERMINATED | 已退出的线程处于此状态 |

    image.png

    • Synchronized（线程同步机制）

      1. 1.在多线程编程，一些敏感数据不允许呗多个线程同时访问，此时就使用同步访问技术，保证数据在
      2. 任何同一时刻，最多有一个线程访问，以保证数据的完整性
      3. 2.也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存
      4. 地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

    • 同步具体方法

      1. 1.同步代码块
      2. synchronized(对象) {     // 得到对象的锁，才能操作同步代码
      3.     // 需要呗同步代码
      4. }
      5. 2.synchronized还可以放在方法声明中，表示整个方法-为同步方法
      6.   public synchronized void m (String name) {
      7.     // 需要呗同步的代码
      8. }

    • 互斥锁

      1. 1.Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
      2. 2.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
      3. 3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻
      4. 只能由一个线程访问
      5. 4.同步方法（非静态的）的锁可以说this，也可以是其他对象（要求是同一个对象）
      6. 5.同步方法（静态的）的锁为当前类本身

    • 互斥锁的注意事项和细节

      1. 1.同步方法如果没有使用static修饰：默认锁对象为this
      2. 2.如果方法使用static修饰：默认锁对象：当前类.class
      3. 3.实现的落地步骤
      4.   需要先分析上锁的代码
      5. 选择同步代码块或者同步方法
      6. 要求多个线程的锁对象为同一个即可！

    • 线程的死锁

      1. 多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程是一定要避免死锁的发生

    • 释放锁 ``` 1.当前线程的同步方法、同步代码块执行结束

    2.当前线程在同步代码块、同步方法中遇到break、return

    3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

    4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

    2. - 不释放锁

    1.线程执行同步代码块或者同步方法时，程序调用thread.sleep()、Thread.yield()方法暂停当前线程的 执行，不会释放锁 2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁 提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

    ```