DAY24 多线程数据安全问题-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43798860/article/details/105135856

多线程数据安全问题

多窗口卖电影票的例子

public class Sales {
  public static void main(String[] args) {
    //创建Runnable子类对象
    SalesTask salesTask = new SalesTask();
    //启动3个线程，模拟3个售票窗口, 实现了三个窗口，售卖共同的100张票
    Thread window1 = new Thread(salesTask, "窗口1");
    Thread window2 = new Thread(salesTask, "窗口2");
    Thread window3 = new Thread(salesTask, "窗口3");
    
    window1.start();
    window2.start();
    window3.start();
  }
}
/*
    定义SalesWindow表示，售票窗口
 */
class SalesTask implements Runnable {
  //表示被售卖的100张票
  int tickets = 100;
  // 作为锁对象的java对象
  private Object lockObj = new Object();
  @Override
  public void run() {
    while (tickets > 0) {
      //卖出了不存在的票的问题的原因
      // 假设 当前tickets的值为1
      // 窗口1线程：窗口1线程，判断当前tickets的值为1 > 0, 于是进入while循环，准备卖票，此时发生线程切换
      // 窗口3线程：判断，当前tickets的值为 1 > 0, 于是进入while循环，准备卖票
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      //  同一张票被多个窗口卖出的问题分析
      // 每一行，就是一个窗口的执行
      //  假设现在，tickets值是99
      //  tickets-- 分成3步来执行的： a. 读取tickets的值    b. tickets - 1  c. tickets = tickets - 1
      //  窗口1: 开始卖票， 拼接售票字符串： 窗口1卖出第99，此时 接着执行 tickets - 1， 此时发生了线程切换，窗口1卖出第99张票
      //  窗口2： 开始卖票， 拼接售票字符串： 窗口2卖出第99，此时执行tickets - 1，线程切换，窗口2卖出第99张票
      System.out.println(Thread.currentThread().getName() + "卖出第" + tickets-- + "张票");
    }
  }
}

产生条件

多线程运行环境（无法打破）
多线程共享数据（无法打破）
对共享操作的非原子操作（打破，将其变为原子操作，即加锁）
原子操作：一种操作，要么不执行，要么一次执行完

JAVA语言如何实现加锁

synchronized

同步代码块

synchronized（锁对象）{
	对多线程原子变量的一组操作
}

synchronized代码块中的锁对象，可以是JAVA语言中的任意对象，因为JAVA中所有对象都存在一个标志位
代码都是在一条路径执行，当线程执行到同步代码块时，会首先尝试加锁锁对象，并记录加锁的线程。让加锁成功的当前线程执行同步代码块中代码
若锁对象已经被加锁且加锁线程不是当前线程，系统会让当前线程处于阻塞状态；直到加锁线程执行完了对共享变量的一组操作，并释放锁
当加锁线程执行完同步代码块中代码（对共享变量的操作），在退出之前，JVM会清理锁对象的标志位
注：如果要保证对于同一个对象的原子操作，锁必须是同一锁对象
静态方法的锁对象也是固定的，就是代表静态方法所属的类
普通成员方法的锁对象就是当前对象this，对象名.锁方法

同步和异步

同步：我走你不走（有锁，其他线程需要等解锁）

优点：可以解决多线程的数据安全问题
缺点：相比异步，等待资源而引发的阻塞，降低了运行效率

异步：你走你的，我走我的（多线程天生异步）
其实：从同步和异步的角度，我们同步代码块，解决多线程数据安全问题

LOCK关键字

Lock lock = new ReentrantLock();
lock.lock();
try {
        if (tickets > 0) {
          System.out.println(Thread.currentThread().getName()
              + "卖出第" + tickets-- + "张票");
        }
      } finally {
        // 保证锁对象在加锁之后，一定会释放锁
        lock.unlock();
      }

lock：一个lock对象就代表一把锁，不需要synchronized关键字配合。
Lock对象： 加锁：lock（），解锁unlock（）

与synchronized对比

JAVA语言中任何一个对象都可以是锁对象，但只有当对象和synchronized配合才作为锁对象，且加锁、解锁都是JVM完成
Lock对象在任何时候都表示一把锁，这把锁的加锁和释放锁都由自己完成
推荐使用synchronized实现同步代码块，简单，lock加锁解锁都需自己操作
从效率角度来讲，使用synchronized和使用Lock对象，效率几乎相同

死锁

死锁问题

产生的原因，通过加锁实现的同步的另一种弊端：当一个线程需要同时持有多把锁，即发生嵌套加锁情况的时候
死锁状态：两个及两个以上的线程，因为争夺资源，而处于相互等待的状态

死锁问题如何解决

修改多线程中加锁顺序，让他们加锁顺序相同
让一个线程一次性持有所有锁

生产者-消费者问题

线程间通信：JAVA中主要通过Object中的方法来实现

wait（）：阻止自己的功能，在其他线程调用此对象notify()或notifyAll()方法前，导致当前线程等待。
若想对一线程调用wait方法，必须拥有此对象监视器（持有锁对象），此外，wait（）除了令线程等待外，，还发布对此监视器的所有权（释放锁）

synchronized (demo1Wait) {
      其他很多代码
      if （特殊条件） {
        demo1Wait.wait();  // IllegalMonitorStateException
      }
}

notify（）：唤醒被wait方法休眠的对象
notifyAll（）：唤醒被wait方法休眠的所有对象