目录

  • 一、临界资源问题
  • 二、多线程同步



在多线程环境下，访问相同的资源，有可以会引发线程不安全问题。

一、临界资源问题

多一个线程同时运行，有时线程之间需要共享数据，一个线程需要其他线程的数据，否则就不能保证 程序运行结果的正确性。
例如有一个航空公司的机票销售，每一天机票数量是有限的，很多售票点同时销售这些机票。
下面是 一个模拟销售机票系统，示例代码如下:

public class TicketDB {
//    机票数量
    private int ticketCount = 5;
//    获得当前机票数量
    public  int getTicketCount(){
        return ticketCount;
    }
//    销售机票
    public void sellTicket(){
        try {
//            等于用户付款
//            等线程休眠
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("第%d号票已经售出\n",ticketCount);
        ticketCount--;
    }
}

调用代码如下:

//测试代码
public class HelloWorld {
    public static void main(String[] args) {
        TicketDB ticketDB = new TicketDB();
//        创建线程
        Thread t1 = new Thread(() -> {
           while (true){
               int currentTicketCount = ticketDB.getTicketCount();
//               查询是否有票
               if (currentTicketCount > 0) {
                   ticketDB.sellTicket();
               } else {
//                   无票退出
                   break;
               }
           }
        });
//       开始线程
        t1.start();

//        创建线程t2
        Thread t2 = new Thread(() ->{
           while (true) {
               int currentTicketCount = ticketDB.getTicketCount();
//               查询是否有票
               if (currentTicketCount > 0) {
                   ticketDB.sellTicket();
               } else {
//                   无票退出
                   break;
               }
           }
        });
//        开始线程
        t2.start();
    }
}

运行结果：

第5号票已经售出
第5号票已经售出
第3号票已经售出
第3号票已经售出
第1号票已经售出
第1号票已经售出

从结果看还是能发现一些问题：同一张票重复销售。这些问题的根本原因是多个线程间共享的数据导致数据的不一致性。
多个线程间共享的数据称为共享资源或临界资源，由于是CPU负责线程的调度，程序员无 法精确控制多线程的交替顺序。这种情况下，多线程对临界资源的访问有时会导致数据的不一致 性。

二、多线程同步

为了防止多线程对临界资源的访问有时会导致数据的不一致性，Java提供了“互斥”机制，可以为这些 资源对象加上一把“互斥锁”，在任一时刻只能由一个线程访问，即使该线程出现阻塞，该对象的被锁 定状态也不会解除，其他线程仍不能访问该对象，这就多线程同步。线程同步保证线程安全的重要手 段，但是线程同步客观上会导致性能下降。

解决方法：可以通过两种方式实现线程同步，两种方式都涉及到使用synchronized关键字，

  • 一种是synchronized方 法，使用synchronized关键字修饰方法，对方法进行同步;
  • 另一种是synchronized语句，使用 synchronized关键字放在对象前面限制一段代码的执行。

先介绍synchronized方法：synchronized关键字修饰方法实现线程同步，方法所在的对象被锁定。

//synchronized方法
public class TicketDB {
//    机票数量
    private int ticketCount = 5;
//    获得当前机票数量
    public synchronized int getTicketCount(){
        return ticketCount;
    }
//    销售机票
    public synchronized void sellTicket(){
        try {
//            等于用户付款
//            等线程休眠
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("第%d号票已经售出\n",ticketCount);
        ticketCount--;
    }
}

再介绍synchronized语句：synchronized语句方式主要用于第三方类，不方便修改它的代码情况。

//synchronized语句
//测试代码
public class HelloWorld {
    public static void main(String[] args) {
        TicketDB ticketDB = new TicketDB();
//        创建线程
        Thread t1 = new Thread(() -> {
           while (true){
               synchronized (ticketDB) {
                   int currentTicketCount = ticketDB.getTicketCount();
//               查询是否有票
                   if (currentTicketCount > 0) {
                       ticketDB.sellTicket();
                   } else {
//                   无票退出
                       break;
                   }
               }
           }
        });
//       开始线程
        t1.start();

//        创建线程t2
        Thread t2 = new Thread(() ->{
           while (true) {
               synchronized (ticketDB) {
                   int currentTicketCount = ticketDB.getTicketCount();
//               查询是否有票
                   if (currentTicketCount > 0) {
                       ticketDB.sellTicket();
                   } else {
//                   无票退出
                       break;
                   }
               }
           }
        });
//        开始线程
        t2.start();
    }
}

测试代码：

第5号票已经售出
第4号票已经售出
第3号票已经售出
第2号票已经售出
第1号票已经售出

使用synchronized语句，将需要同步的代码用大括号括起来。synchronized 后有小括号，将需要同步的对象括起来。

以上内容仅供参考学习，如有侵权请联系我删除！
如果这篇文章对您有帮助，左下角的大拇指就是对博主最大的鼓励。
您的鼓励就是博主最大的动力！