Java多线程-线程安全问题

线程安全问题

案例

需求：某电影院目前正在上映国产大片，共有10张票，而它只有3个窗口售票，设计一个程序模拟该电影院卖票

思路：

① 定义一个Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;

② 在Ticket类中重写run()方法实现卖票，代码步骤如下：

​ A：判断如果票数大于0，卖票，并告知售票窗口名称

​ B：票数减1

​ C：卖光之后，线程就停止

③ 定义一个测试类TicketDemo，里面有main方法，代码步骤如下：

​ A：创建Ticket类的对象

​ B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应窗口的名称

• Ticket类

  package com.cmy.threaddemo9;
  
  /**
   * @author 陈明勇
   */
  public class Ticket implements Runnable {
      private static int ticket = 10;
  
      @Override
      public void run() {
          while (true) {
              if (ticket == 0) {
                  // 卖光了
                  break;
              } else {
                  ticket--;
                  System.out.println(Thread.currentThread().getName() + "在卖票中，还剩下" + ticket + "张票");
              }
          }
      }
  }
  
  

• TicketDemo类

  package com.cmy.threaddemo9;
  
  /**
   * @author 陈明勇
   */
  public class TicketDemo {
  
      public static void main(String[] args) {
          Ticket ticket = new Ticket();
  
          Thread t1 = new Thread(ticket);
          t1.setName("窗口1");
          Thread t2 = new Thread(ticket);
          t2.setName("窗口2");
          Thread t3 = new Thread(ticket);
          t3.setName("窗口3");
  
          t1.start();
          t2.start();
          t3.start();
      }
  }
  
  

• 测试结果

  窗口3在卖票中，还剩下7张票
  窗口1在卖票中，还剩下7张票
  窗口2在卖票中，还剩下7张票
  窗口1在卖票中，还剩下5张票
  窗口3在卖票中，还剩下6张票
  窗口3在卖票中，还剩下2张票
  窗口3在卖票中，还剩下1张票
  窗口3在卖票中，还剩下0张票
  窗口1在卖票中，还剩下3张票
  窗口2在卖票中，还剩下4张票
  

• 结果分析

  有重复票

案例改进

在现实生活中，售票也是需要时间的，所以得设置每次出票时间100毫秒，可以使用sleep()方法实现

Ticket类

package com.cmy.threaddemo9;

/**
 * @author 陈明勇
 */
public class Ticket implements Runnable {
    private static int ticket = 10;

    @Override
    public void run() {
        while (true) {
            if (ticket == 0) {
                // 卖光了
                break;
            } else {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket--;
                System.out.println(Thread.currentThread().getName() + "在卖票中，还剩下" + ticket + "张票");
            }
        }
    }
}

测试结果

窗口1在卖票中，还剩下7张票
窗口3在卖票中，还剩下7张票
窗口2在卖票中，还剩下7张票
窗口3在卖票中，还剩下5张票
窗口1在卖票中，还剩下4张票
窗口2在卖票中，还剩下5张票
窗口2在卖票中，还剩下3张票
窗口1在卖票中，还剩下1张票
窗口3在卖票中，还剩下2张票
窗口1在卖票中，还剩下-1张票
窗口3在卖票中，还剩下-2张票
窗口2在卖票中，还剩下0张票
窗口1在卖票中，还剩下-3张票
窗口2在卖票中，还剩下-3张票
窗口3在卖票中，还剩下-4张票
窗口3在卖票中，还剩下-6张票

有重复票，而且还有负号票

将条件改成<=0

if (ticket <= 0) {
    // 卖光了
    break;
}

结果还是会有负号票

原因分析

在窗口1休眠时，窗口2或窗口3抢到了CPU的执行权，他们都停在sleep()代码处，接着窗口1或2或3在执行打印票数的代码时，其他窗口可能会抢到CPU的执行权，也来到了执行打印票数的代码这块，这时他们都有可能输出重复票。

---

在其他窗口判断票小于等于0的时候，就会结束循环，这时其他窗口可能还在准备执行执行打印票数的，这是就会有负号票的产生

卖票数据安全问题的解决

• 为什么会出现问题？

  多线程操作共享数据

• 如何解决多线程安全问题？

  基本思想：让程序没有安全问题的环境

• 如何实现？

  把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

• java提供了同步代码块的方式解决

同步代码块

锁多条语句操作共享数据，可以使用同步代码块实现

• 格式

  synchronized(任意对象) {
  	条语句操作共享数据的代码
  }
  

• synchronized默认情况是打开的，只要有一个线程进去执行代码，锁就会关闭

• 当线程执行完毕出来后，锁才会自动打开

• 同步的好处和弊端

  好处：解决了多线程的数据安全问题

  弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

• 代码改进

  package com.cmy.threaddemo9;
  
  /**
   * @author 陈明勇
   */
  public class Ticket implements Runnable {
      private static int ticket = 10;
      private static Object obj = new Object();
  
      @Override
      public void run() {
          while (true) {
              // 多个线程必须使用同一把锁
              synchronized (obj) {
                  if (ticket <= 0) {
                      // 卖光了
                      break;
                  } else {
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      ticket--;
                      System.out.println(Thread.currentThread().getName() + "在卖票中，还剩下" + ticket + "张票");
                  }
              }
          }
      }
  }
  
  

  多个线程必须使用同一把锁

同步方法

同步方法：就是把synchronized关键字加到方法上

• 格式：

  修饰符 synchronized 返回值类型 方法名(方法参数) {}

• 同步代码块和同步方法的区别

  • 同步代码块可以锁住指定代码，而同步方法是锁着方法中的所有代码
  • 同步代码块可以指定锁对象，同步方法不能指定锁对象

• 同步方法的锁对象是什么？

  this

同步静态方法

同步静态方法：就是把synchronized关键字加到静态方法上

• 格式：

  修饰符 static synchronized 返回值类型 方法名(方法参数) {}

• 同步静态方法的锁对象是什么？

  类名.class 字节码文件的对象

Lock锁

Lock锁实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

lock中提供了获得锁和释放锁的方法

• void lock(): 获得锁
• void unlock(): 释放锁

lock是接口，不能直接实例化，可以采用ReentrantLock来实例化

ReentrantLock的构造方法

• ReentrantLock(): 创建一个ReentrantLock的实例

ReentrantLock lock = new ReentrantLock();
try {
    lock.lock();
    ------其他代码块-----
}
catch (Exception e) {
    e.printStackTrace();
}
finally {
	lock.unlock();
}

死锁

线程死锁是指由于两个或者多个线程相互持有对方所需资源，导致这些线程处于等待状态，无法往前执行。