javajavase

线程的生命周期

image.png

线程的五种状态

  • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被star()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CP∪并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

image.png

有4种原因会导致阻塞

  • 执行Thread.sleep()方法，使当前线程休眠进入阻塞状态。当指定的时间到了后，线程进入就绪状态
  • 执行wait()方法使当前线程进入阻塞状态，使用nofity()方法唤醒这个线程后，它进入就绪状态
  • 线程运行时某个操作进入阻塞状态，如执行IO流操作(read()/write()方法本身就是阻塞的方法)，只有当引起该操作阻塞的原因消失后线程进入就绪状态
  • join()插队线程: 当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法

  • 每个对象都有个锁，sleep()不会释放锁,时间到了重新进入就绪状态

    有4中原因会导致线程进入就绪状态

  • 新建线程：调用start()方法，进入就绪状态

  • 阻塞线程：阻塞解除，进入就绪状态
  • 运行线程：调用Thread.yield()方法，直接进入就绪状态

  • 运行线程：JVM将CPU资源从本线程切换到其他线程

    死亡

  • 一个是正常运行的线程完成了它run()方法内的全部工作

  • 一个是线程被强制终止，如通过执行stop()或destroy()方法来终止一个线程stop()/destroy()已废弃)
  • 通常的做法是提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行

线程的同步机制

背景
例子：创建3个窗口卖票，总票数为100张

  • 问题：卖票过程中，出现了重票、错票—>出现了线程的安全问题
  • 原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
  • 解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变

在Java中，我们通过同步机制，来解决线程的安全问题
说明

  • 操作共享数据的代码，即为需要被同步的代码—>不能包含代码多了，也不能包含代码少了
  • 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
  • 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
    • 要求多个线程必须要共用同一把锁

考虑

  • 在实现Runnable接口创建多线程的方式中，任何一个对象都能充当锁，可以考虑使用this充当同步监视器
  • 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

释放锁

  • 执行结束
  • break、return终止代码
  • error、Exception未处理
  • wait()方法

不释放锁

  • Thread.sleep()
  • Thread.yeild()

  • suspend()

    方式一：同步代码块

    1. synchronized(同步监视器) {    //同步监视器就是需要同步线程的公共对象
    2.   //需要被同步的代码
    3. }

    继承 Runnable 接口形式同步代码块

    ```java public class Ticket implements Runnable { private int tick = 100;

    @Override public void run() {

    1.   while (true) {
    2.       synchronized (this) {
    3.           if (tick > 0) {
    4.               System.out.println(Thread.currentThread().getName() 
    5.                                  + "号窗口买票，票号为：" + tick--);
    6.           } else
    7.           break;
    8.       }
    9.   }

    } }

class TicketTest { public static void main(String[] args) { Ticket ticket = new Ticket();
Thread thread1 = new Thread(ticket, “窗口1”);//ticket的属性为多个线程共享 Thread thread2 = new Thread(ticket, “窗口2”); Thread thread3 = new Thread(ticket, “窗口3”); thread1.start(); thread2.start(); thread3.start(); } }

  1. <a name="d2sVQ"></a>
  2. #### 继承 Thread 类形式同步代码块
  3. ```java
  4. public class Window2 extends Thread {
  5.     private static int tick = 100;
  6.     //private static Object object = new Object();
  8.     public Ticket2() {
  9.     }
  11.     @Override
  12.     public void run() {
  13.         while (true) {
  14.             //正确的
  15.             //            synchronized (obj) {
  16.             synchronized (Window2.class) {    //Class clazz = Window2.class,类对象只会加载一次
  17.             //              synchronized (this) {    //错误的方式：this代表着t1,t2,t3三个对象
  18.                 if (tick > 0) {
  19.                     System.out.println(Thread.currentThread().getName() 
  20.                                        + "号窗口买票，票号为" + tick--);
  21.                 } else {
  22.                     break;
  23.                 }
  24.             }
  25.         }
  26.     }
  27. }
  29. class TicketTest2 {
  30.     public static void main(String[] args) {
  31.         new Thread("窗口1").start();
  32.         new Thread("窗口2").start();
  33.         new Thread("窗口3").start();
  34.     }
  35. }

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

  1. //使用同步方法解决实现Runnable接口的线程安全问题
  2. public class Ticket3 implements Runnable {
  3.     private int tick = 100;
  4.     private boolean isFlag = true;
  6.     @Override
  7.     public void run() {
  8.         while (isFlag) {
  9.             show();
  10.         }
  11.     }
  13.     public synchronized void show() {//同步监视器：this
  14.         if (tick > 0) {
  15.             try {
  16.                 Thread.sleep(100);
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.             System.out.println(Thread.currentThread().getName() 
  21.                                + "号窗口买票，票号为：" + tick--);
  22.         } else {
  23.             isFlag = false;
  24.         }
  25.     }
  26. }
  28. class TicketTest3 {
  29.     public static void main(String[] args) {
  30.         Ticket3 ticket = new Ticket3();
  31.         new Thread(ticket, "窗口1").start();
  32.         new Thread(ticket, "窗口2").start();
  33.         new Thread(ticket, "窗口3").start();
  34.     }
  35. }
  1. //使用同步方法处理继承Thread类的方式中的线程安全问题
  2. class Window4 extends Thread {
  3.     private static int ticket = 100;
  5.     @Override
  6.     public void run() {
  7.         while (true) {
  8.             show();
  9.         }
  10.     }
  12.     private static synchronized void show() {    //同步监视器：Window4.class
  13.         // private synchronized void show() {    //同步监视器：t1,t2,t3。此种解决方式是错误的
  14.         if (ticket > 0) {
  15.             try {
  16.                 Thread.sleep(100);
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.             System.out.println(Thread.currentThread().getName() 
  21.                                + "：卖票，票号为：" + ticket);
  22.             ticket--;
  23.         }
  24.     }
  25. }
  27. public class WindowTest4 {
  28.     public static void main(String[] args) {
  29.         new Thread("窗口1").start();
  30.         new Thread("窗口2").start();
  31.         new Thread("窗口3").start();
  32.     }
  33. }

关于同步方法的总结

  • 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
  • 非静态的同步方法，同步监视器是：this

  • 静态的同步方法，同步监视器是：当前类本身

    线程安全的单例模式

    1. //使用同步机制将单例模式中的懒汉式改写为线程安全的。
    2. class Bank {
    3.   private Bank() {}
    5.   private static volatile Bank instance = null;
    7.   public static Bank getInstance() {
    8.       //方式一：效率稍差
    9.       //        synchronized (Bank.class) {
    10.       //            if(instance == null) {
    11.       //                instance = new Bank();
    12.       //            }
    13.       //            return instance;
    14.       //        }
    16.       //方式二：效率更高
    17.       //原因：当一个线程创建bank对象后，除了进入第一个if被阻塞的几个线程外，后续线程不会被阻塞
    18.       if(instance == null) {
    19.           synchronized (Bank.class) {
    20.               if(instance == null) {
    21.                   instance = new Bank();
    22.               }
    23.           }
    24.       }
    25.       return instance;
    26.   }
    27. }

    死锁问题

    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
    说明：出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
    死锁条件：互斥条件、请求与保持条件、不可剥夺条件、循环等待条件

  • 解决办法

    • 专门的算法、原则
    • 尽量减少同步资源的定义

    • 尽量避免嵌套同步

      1. public static void main(String[] args) {
      2. StringBuffer s1 = new StringBuffer();
      3. StringBuffer s2 = new StringBuffer();
      5. new Thread(){
      6.    @Override
      7.    public void run() {
      8.        synchronized (s1){
      9.            s1.append("a");
      10.            s2.append("1");
      11.            try {
      12.                Thread.sleep(100);
      13.            } catch (InterruptedException e) {
      14.                e.printStackTrace();
      15.            }
      16.            synchronized (s2){
      17.                s1.append("b");
      18.                s2.append("2");
      19.                System.out.println(s1);
      20.                System.out.println(s2);
      21.            }
      22.        }
      23.    }
      24. }.start();
      26. new Thread(new Runnable() {
      27.    @Override
      28.    public void run() {
      29.        synchronized (s2){
      30.            s1.append("c");
      31.            s2.append("3");
      32.            try {
      33.                Thread.sleep(100);
      34.            } catch (InterruptedException e) {
      35.                e.printStackTrace();
      36.            }
      37.            synchronized (s1){
      38.                s1.append("d");
      39.                s2.append("4");
      40.                System.out.println(s1);
      41.                System.out.println(s2);
      42.            }
      43.        }
      44.    }
      45. }).start();
      46. }

      synchronized的底层实现

      image.png

      方式三：Lock锁 —- JDK 5.0新增

      从JDK 5.0开始，Java提供了更强大的线程同步机制—通过显式定义同步锁对象来实现同步
      同步锁使用Lock对象充当

  • java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

  • ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 Reentrantlock，可以显式加锁、释放锁 ```java class A { // 1.实例化ReentrantLock对象 // 可加参数fair，true表示为公平锁，1 2 3三个线程先后到达则先后获得lock，不填则为false private final ReentrantLock lock = new ReentrantLock();

    public void m (){

    1.   lock.lock()            //2.先加锁
    2.   try{
    3.       //保证线程同步的代码
    4.   }finally{
    5.       lock.unlock();    //3.后解锁
    6.   }

    } }

//注意：如果同步代码块有异常，要将unlock()写入finally语句块中

  1. ```java
  2. class Window implements Runnable{
  3.     private int ticket = 100;
  5.     // 1.实例化ReentrantLock
  6.     private ReentrantLock lock = new ReentrantLock();
  8.     @Override
  9.     public void run() {
  10.         while(true){
  11.             try{
  12.                 // 2.调用锁定方法lock()
  13.                 lock.lock();
  14.                 if(ticket > 0){
  15.                     try {
  16.                         Thread.sleep(100);
  17.                     } catch (InterruptedException e) {
  18.                         e.printStackTrace();
  19.                     }
  20.                     System.out.println(Thread.currentThread().getName() 
  21.                                        + "：售票，票号为：" + ticket);
  22.                     ticket--;
  23.                 }else{
  24.                     break;
  25.                 }
  26.             }finally {
  27.                 // 3.调用解锁方法：unlock()
  28.                 lock.unlock();
  29.             }
  30.         }
  31.     }
  32. }
  34. public class LockTest {
  35.     public static void main(String[] args) {
  36.         Window w = new Window();
  37.         new Thread(ticket, "窗口1").start();
  38.         new Thread(ticket, "窗口2").start();
  39.         new Thread(ticket, "窗口3").start();
  40.     }
  41. }

同步方法的总结

在《 Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他仼务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

synchronized的锁是什么：

  • 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
  • 同步方法的锁：非静态方法（this）、静态方法（类名.class）
  • 同步代码块：自己指定，很多时候也是指定为 this 或 类名.class

注意点：

  • 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全

同步的范围
如何找问题，即代码是否存在线程安全？（非常重要）

  • 明确哪些代码是多线程运行的代码
  • 明确多个线程是否有共享数据
  • 明确多线程运行代码中是否有多条语句操作共享数据

如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中其他线程不可以参与执行。 即所有操作共享数据的这些语句都要放在同步范围中
注意点
范围太小：没锁住所有有安全问题的代码
范围太大：没发挥多线程的功能

面试题
synchronized 与 Lock的异同？
相同
二者都可以解决线程安全问题
不同

  • synchronized 机制在执行完相应的同步代码以后，自动的释放同步监视器
  • Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
  • Lock有lockinterruptibly、tryLock等多种锁的方式
  • ReentrantLock可以设置是否公平锁

优先使用顺序

  • Lock >同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

利弊

  • 同步的方式，解决了线程的安全问题。—-好处 操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ```java //银行有一个账户。 //有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。 分析： 1.是否是多线程问题？ 是，两个储户线程 2.是否有共享数据？ 有，账户（或账户余额） 3.是否有线程安全问题？ 有 4.需要考虑如何解决线程安全问题？ 同步机制：有三种方式。

class Account{ private double balance;

  1. public Account(double balance) {
  2.     this.balance = balance;
  3. }
  5. public synchronized void deposit(double amt){ // 存钱
  6.     if(amt > 0){
  7.         balance += amt;
  8.         try {
  9.             Thread.sleep(1000);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         System.out.println(Thread.currentThread().getName() 
  14.         + ":存钱成功。余额为：" + balance);
  15.     }
  16. }

}

class Customer extends Thread{ private Account acct;

  1. public Customer(Account acct) {
  2.     this.acct = acct;
  3. }
  5. @Override
  6. public void run() {
  7.     for (int i = 0; i < 3; i++) {
  8.         acct.deposit(1000);
  9.     }
  10. }

}

public class AccountTest { public static void main(String[] args) { Account acct = new Account(0); new Customer(acct, “甲”).start(); new Customer(acct, “乙”).start(); } } ```

死锁

死锁必要条件

  • 互斥访问
  • 请求与保持
  • 循环等待

  • 不可剥夺

    死锁编码与定位分析

  • jps 定位进程号

    • ps -ef | java 查看java进程
    • jps 就是 java ps 可以查看运行程序的进程号

image.png

  • jstack 找到死锁
    • jstack 9636

image.png