三大不安全案例的问题及解决方式

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量169 收藏
点赞数
分类专栏： # 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59448049/article/details/124592597
版权

一、买票问题

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

package com;
//不安全的买票
//线程不安全，有负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        Thread t1 = new Thread(station,"我");
        Thread t2 = new Thread(station,"你");
        Thread t3 = new Thread(station,"他");
        t1.start();
        t2.start();
        t3.start();
    }
}

class BuyTicket implements Runnable{
   //买票
    private  int ticketNums =10;
    boolean flag=true;//外部停止方式

    @Override
    public void run() {
       //买票
        while(flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    private void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

运行界面如下： 

二、银行取钱问题

package com.rgf;

import com.rgf.Exception.Deno02;

//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
  public static void main(String[] args) {
    //账户
    Account account = new Account(100,"结婚基金");
    Drawing you = new Drawing(account,50,"你");
    Drawing girlfriend = new Drawing(account,100,"grilfriend");
    you.start();
    girlfriend.start();




  }
}


//账户
class Account{
  int money;  //余额
  String name; //卡名

  public Account(int money, String name) {
    this.money = money;
    this.name = name;
  }
}

//银行：模拟取款
class Drawing extends Thread{
  Account account;//账户
  //取了多少钱
  int drawingMoney;
  //现在手里有多少钱
  int nowMoney;
  //构造方法
  public Drawing(Account account,int drawingMoney,String name ){
    super(name);
    this.account=account;
    this.drawingMoney=drawingMoney;

  }
 //取钱的操作
  @Override
  public void run() {
   //判断有没有钱
    if(account.money-drawingMoney<0){
      System.out.println(Thread.currentThread().getName()+"钱不够,取不了");
      return;
    }
    //sleep可以放大问题的发生性
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    //卡内余额=余额-你取的钱
    account.money=account.money-drawingMoney;
    //你手里的钱
    nowMoney=nowMoney+drawingMoney;

    System.out.println(account.name+"余额为:"+account.money);
    //Thread.currentThread().getName()=this.getName(),this指代继承的Thread类。
    System.out.println(this.getName()+"手里的钱："+nowMoney);
  }
}

运行界面如下所示：

 三、多线程问题：

package com.rgf;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行界面：

 add会覆盖掉其中的部分，导致出现问题。

同步方法及同步块：

由于我们可以通过private关键字来保证数据对象只能被方法访问（通过get和set方法），所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：

synchronized方法和synchronized块。

同步方法：public synchronized void method(int args){}

synchronized方法控制对”对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

缺陷：若将一个大的方法申明为synchronized将会影响效率

方法里面需要修改的内容才需要锁。锁的太多，浪费资源。

同步块：synchronized（Obj){}

Obj称之为同步监视器

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者是class[反射中讲解}

同步监视器的执行过程：

1.第一个线程访问，锁定同步监视器，执行其中代码

2.第二个线程访问，发现同步监视器被锁定，无法访问

3.第一个线程访问完毕，解锁同步监视器

4.第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

利用同步方法对上述的三大不安全案例进行修改如下：

取票安全问题：锁购票方法即可

package com;
//安全的买票
//线程不安全，有负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        Thread t1 = new Thread(station,"我");
        Thread t2 = new Thread(station,"你");
        Thread t3 = new Thread(station,"他");
        t1.start();
        t2.start();
        t3.start();
    }
}

class BuyTicket implements Runnable{
   //买票
    private  int ticketNums =10;
    boolean flag=true;//外部停止方式

    @Override
    public void run() {
       //买票
        while(flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized  同步方法，锁的是this
    private synchronized void buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

运行界面如下所示：

 银行取款安全问题如下所示：锁run方法里面的账户即可.

package com.rgf;

import com.rgf.Exception.Deno02;

//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
  public static void main(String[] args) {
    //账户
    Account account = new Account(100,"结婚基金");
    Drawing you = new Drawing(account,50,"你");
    Drawing girlfriend = new Drawing(account,100,"grilfriend");
    you.start();
    girlfriend.start();




  }
}


//账户
class Account{
  int money;  //余额
  String name; //卡名

  public Account(int money, String name) {
    this.money = money;
    this.name = name;
  }
}

//银行：模拟取款
class Drawing extends Thread{
  Account account;//账户
  //取了多少钱
  int drawingMoney;
  //现在手里有多少钱
  int nowMoney;
  //构造方法
  public Drawing(Account account,int drawingMoney,String name ){
    super(name);
    this.account=account;
    this.drawingMoney=drawingMoney;

  }
 //取钱的操作
  //synchronized默认锁的是this
  @Override
  public void run() {
    
    //锁的对象就是变化的量，需要增删改的对象
    synchronized (account) {
      //判断有没有钱
      if (account.money - drawingMoney < 0) {
        System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
        return;
      }
      //sleep可以放大问题的发生性
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      //卡内余额=余额-你取的钱
      account.money = account.money - drawingMoney;
      //你手里的钱
      nowMoney = nowMoney + drawingMoney;

      System.out.println(account.name + "余额为:" + account.money);
      //Thread.currentThread().getName()=this.getName(),this指代继承的Thread类。
      System.out.println(this.getName() + "手里的钱：" + nowMoney);
    }
  }
}

运行界面如下所示:

 增加数据的安全问题：(锁增加的数据方法即可）

package com.rgf;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行界面如下所示：

 与此同时JUC也可以实现相同的效果：
 

package com.rgf;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合,并发领域。
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();//泛型加上
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行界面如下所示：

一直再追梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
动力电池10大安全问题及解决思路
01-14
以下是某会议的精髓，提出探讨动力电池十大安全问题：1.电芯安全 2.成组安全 3.电池管理 4.设计安全 5.充电安全 6.使用安全 7.安全预警 8.日常维护 9.安全保护 10.安全等级划分。本整理稿件是从10个问题中挑选3个...
Java多线程-同步机制解决线程安全问题方式二：同步方法
01-30
在Java多线程编程中，线程安全问题通常是指多个线程访问共享资源时可能出现的不一致或错误状态。为了确保并发执行的线程能够正确地处理这些共享资源，Java提供了多种同步机制，其中之一就是同步方法。同步方法通过在...
三大不安全案例
Mr.Rop的博客
02-22 3377
队列+锁能解决这个问题 不安全买票案例 // 可能出现负数 public class UnSafeBuyTicket { public static void main(String[] args) { BuyTicket station = new BuyTicket(); new Thread(station,"小明").start(); new Thread(station,"小红").start(); new Thread
多线程——三大不安全案例
beishanqiye的博客
09-18 371
买票 package thread; //不安全的买票 public class ThreeUnsafeCases { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"You").start(); new Thread(buyTicket,"I").start(); new Th
多线程14：三大不安全案例
GoodIdea
02-23 2141
案例一：火车站买票 思路： 1.首先要有一个买票的类BuyTicket多线程要实现Runnable接口，重写run()里面是买票， 2.买票就需要有票，定义一个票的变量 private int ticketNums = 10; 3.写一个买票的方法buy():首先你得判断是否有票，if(ticketNums<=0),就停止return； 4.否则就买票，直接ticketNums--就可以了。谁+拿到+第几张票 5.然后需要一个循环，在while方法里面写，定义一个外部标志位，然后调用方
java多线程（一）
m0_44959626的博客
03-28 104
1.多线程简介 process(进程)&thread(线程) 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 进程是执行程序的一次执行过程，它是一个动态的概念，是系统分配资源的单位 一个进程中包含若干个线程，当然一个进程中至少有一个线程，不然没有其存在的意义，线程是CPU调度和执行的单位 注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器，如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有
线程安全的三大不安全案例及解决方法
IAMZTDSF的博客
04-08 442
1.没有排队导致线程不安全 示例：不安全买票 原因：每个线程都有自己的工作内存，内存控制不当会造成数据不一致（最后一张票被多个线程同时载入内存） package syn; public class UnsafeBuyTicket { public static void main(String[] args) { BuyTickey station = new BuyTickey(); new Thread(station,"我").start();
依赖性问题：解决全球开源软件安全问题.docx
12-13
依赖性问题：解决全球开源软件安全问题 依赖性问题是当前全球开源软件安全的主要挑战之一。 开源软件供应链可能会引入未知的、可能是有意的平安漏洞。依赖于其他组件的组件无限地依赖于其他组件，使得阻止攻击变得...
Java使用同步方法解决银行取钱的安全问题案例分析
08-25
Java 使用同步方法解决银行取钱的安全问题案例分析主要介绍了 Java 使用同步方法解决银行取钱的安全问题，结合具体案例形式分析了 Java 同步方法实现多线程安全操作银行取钱问题。 一、同步方法 同步方法是使用 ...
大中型企业网络安全整体解决方案.pptx
02-04
### 大中型企业网络安全整体解决方案 #### 一、安全趋势及需求分析 随着信息技术的快速发展，尤其是移动互联网、社交网络、大数据、机器学习、人工智能、物联网、云计算、区块链等技术的广泛应用，企业的业务模式...
Java多线程（总）
爱学习的小段的博客
03-30 498
Process进程与Thread线程 线程状态 线程优先级 线程同步 线程通信
出现这个错误的解决方法No enclosing instance of type 类名 is accessible. Must qualify the allocation with
just_learing的博客
03-14 8081
出现这个错误的解决方法No enclosing instance of type 类名 is accessible. Must qualify the allocation with
1.0、Java多线程——线程、进程、多线程的概念
m0_52433668的博客
07-15 158
如果是模拟出来的多线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。就比如说我们在边看书的同时听音乐，这两件事情看上去我们的确是是同时进行的，但是我们大脑的一瞬间要么在看书要么在听音乐，只是这两者切换的很快很快，我们无法察觉。4、在一个进程中，如果开辟了多个线程，线程的运行有调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；2、在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；说起进程，就不得不说下。.
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
m0_56013912的博客
03-11 607
　　很多多线程是模拟出来的，真整的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，在一个cpu的情况下，同一个时间点，cpu只能执行一个代码，因为切换的快，所以就有同时执行的错觉。 　　? @线程是独立的执行路径 　　? @在程序运行时，即使自己没有创建线程，后台也会有多个线程，如主线程，gc线程 　　? @在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预 　　? @线程会带来额外的开销，如cpu调度时间，并发控制开销 　　?
线程详解及面试题（一）
weixin_46046339的博客
07-05 134
程序、进程、线程的关系 程序是指令和数据的有序集合，其本身没有任何的运行意义，是一个静态的概念。 进程是执行程序一次执行的过程，是一个动态的概念，是系统分配资源的单位。 通常在一个进程中可以包含多个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位。 线程核心概念 线程就是独立的执行路径 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程（垃圾回收线程） main（）称之为主线程，为系统的入口，用于执行整个程序 在一个进程中，如果开辟了多个线程
golang 接口
m0_70982551的博客
07-24 813
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 422
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 506
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java多线程：同步方法解决线程安全问题深入解析
"Java多线程中使用同步方法来解决线程安全问题的案例分析" 在Java多线程编程中，线程安全是一个至关重要的概念，特别是在多个线程访问共享资源时。为了确保数据的一致性和完整性，Java提供了多种同步机制，其中之一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一直再追梦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值