JAVA Review-应用程序开发-JAVA多线程-线程安全

清疚 2022-05-22 09:56 248阅读 0赞

前言

在上一章节中我们学习了JAVA 实现多线程的方式。在实际的开发过程中应用程序对线程应用和要求要比我们想象地要复杂。上节的两个例子只是简单地实现了多线程，但在线程安全上我们没有并没有做过多的思考和设计。
上节中的两个例子实现的多线程都具有一个特点：不论以那种方式实现的多线，线程与线程之间没有任何地联系，也不存在数据公用的问题。此时多线程的实现并不存在所谓的线程安全问题， 当在一些其他的场景中我们往往需要多个线程同时操作一个或者多个公用数据，此时多线程间将存在着线程安全问题。

典型地线程安全案例分析

首先我们通过一个简单的例子来说明多线程间的线程安全问题。

  • 事例分析(基于继承Thread类的多线程的实现)

    • 场景说明
      现在在某售票厅有100张票，从第一张开始卖，分三个窗口出售，模拟一个客户购票结果。

    • 代码实现

      1. package coreJavaReview.thread;
      3. public class ThreadPurchaseTikect { 
      4.     public static void main(String[] args) {
      5.         Purchanse p1 = new Purchanse();
      6.         Purchanse p2 = new Purchanse();
      7.         Purchanse p3 = new Purchanse();
      9.         p1.setName("第一个窗口");
      10.         p2.setName("第二个窗口");
      11.         p3.setName("第三个窗口");
      13.         p1.start();
      14.         p2.start();
      15.         p3.start();
      16.     }
  1.         }
  3.         class Purchanse extends Thread{ 
  4.             static int i = 1;
  5.              public void run(){
  6.                  while(true){
  7.                      if(i<=100){
  8.                          try {
  9.                              Thread.currentThread().sleep(1000);
  10.                         } catch (Exception e) {
  11.                         }
  12.                          System.out.println(Thread.currentThread().getName()+"出售了第"+i+"张票");
  13.                          i++;
  14.                      }
  15.                  }
  16.              }
  17.         }
  18.  *  结果(部分结果)
  20.         第一个窗口出售了第97张票
  21.         第二个窗口出售了第97张票
  22.         第三个窗口出售了第97张票
  23.         第二个窗口出售了第100张票
  24.         第一个窗口出售了第100张票
  25.         第三个窗口出售了第101张票
  26.  *  问题分析
  28.      *  随着线程sleep的时间越长线程安全问题越明显：三个窗口能同一时间出售同一张票，最后还多买了一张票(第101张)。

  • 事例分析(基于实现Runnable接口的多线程的实现)

    • 场景说明
      现在在某售票厅有100张票，从第一张开始卖，分三个窗口出售，模拟一个客户购票结果。

    • 代码示例

      1. package coreJavaReview.thread;
      3. public class ThreadPurchaseTikectRunnable { 
      5.     public static void main(String[] args) {
      6.         PurchaseTikectRunnbale p1 = new PurchaseTikectRunnbale();
      7.         PurchaseTikectRunnbale p2 = new PurchaseTikectRunnbale();
      8.         PurchaseTikectRunnbale p3 = new PurchaseTikectRunnbale();
      10.         Thread t1 = new Thread(p1);
      11.         Thread t2 = new Thread(p2);
      12.         Thread t3 = new Thread(p3);
      14.         t1.setName("第一个窗");
      15.         t2.setName("第二个窗");
      16.         t3.setName("第三个窗");
      18.         t1.start();
      19.         t2.start();
      20.         t3.start();
      22.     }
      23. }
      25. class PurchaseTikectRunnbale implements Runnable{ 
      26.     static int i = 1;
      27.      public void run(){
      28.          while(true){
      29.              if(i<=100){
      30.                  try {
      31.                      Thread.currentThread().sleep(1000);
      32.                 } catch (Exception e) {
      33.                 }
      34.                  System.out.println(Thread.currentThread().getName()+"出售了第"+i+"张票");
      35.                  i++;
      36.              }
      37.          }
      38.      }
      39. }

    • 结果(部分结果)

      1. 第二个窗出售了第97张票
      2. 第一个窗出售了第97张票
      3. 第三个窗出售了第99张票
      4. 第一个窗出售了第100张票
      5. 第二个窗出售了第100张票
      6. 第三个窗出售了第102张票
    • 问题分析 
  1.      *  随着线程sleep的时间越长线程安全问题越明显：三个窗口能同一时间出售同一张票，最后还多买了一张票(第101张)。
  • 问题小结
    由上面两个事例我们可以看见在JAVA多线程中若多线程间操作同意数据将会出现线程安全问题(比如多个窗口买同一张票，错票等现象)

发表评论

表情：
评论列表 （有 0 条评论，248人围观）

还没有评论，来说两句吧...

相关阅读