线程同步机制和三个线程不安全例子

快来打我* 2022-10-21 11:58 136阅读 0赞

**并发**: 同一个对象被多个线程同时操作;

> 1.由于同一进程的多个线程共享同一块存储空间,会发生访问冲突问题.为了访问的正确性,在访问时加入了锁机制(synchronized) 。当一个线程获得对象的排它锁时，独占资源，其他线程必须等待，使用后释放锁即可。  
> 2.一个线程持有锁会导致其他所有需要此锁的线程挂起；  
> 3.在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；  
> 4.如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

**1.抢票不安全问题**

//多个线程处理同一资源时，线程不安全会出现数据紊乱
    public class UnsafeBuyTicket {
        
        public static void main(String[] args) {
        
           Myticket myticket = new Myticket();
           new Thread(myticket,"用户1").start();
           new Thread(myticket,"用户2").start();
           new Thread(myticket,"用户3").start();
        }
    }
    //买票的类
    class Myticket implements Runnable{
        
        private int tickets = 10;//设置总票数
          boolean flag = true;//采用外部停止的方式
          
        @Override
        public void run() {
        //run()方法的作用是票未抢完时，不断更新抢票的状态
            //买票
            while (flag){
        
                try {
        
                    buy();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
        //判断是否有票
        private void buy() throws InterruptedException {
        
            while (flag){
        
                if(tickets<=0) {
        
                    flag = false;
                    return;
                }
                //模拟延时
                Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"抢到了第"+tickets--+"张票");}
        }

抢票结果会出现负数，线程不安全  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center]  
**2.同时取钱不安全**  
实现思路：  
1.先创建账户，包含**账户名字**和**余额**两个变量，为实现接收输入-构造器  
2创建取款类并继承Thread类，银行取款流程：账户信息+取款金额+判断余额是否大于取款金额，实现多个线程同时取款继承Thread类-重写run()方法  
3.在main()方法要给Thread类中传递名字，在Thread的子类构造器第一行调用**super(name)**;  
4.在run()方法中具体实现余额判断更新

//不安全事件
    //模拟银行取钱
    public class UnsafaBank {
        
        public static void main(String[] args) {
        
          Account account = new Account(100,"卡内");
    
            Drawing drawing01 = new Drawing(account,50,"用户1");
            Drawing drawing02 = new Drawing(account,100,"用户2");
            drawing01.start();
            drawing02.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;
            }
            //模拟延时,放大问题的发生性
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            //账户剩余的钱
            account.money = account.money-drawingmoney;
            //手里的钱
            nowmoney = nowmoney+drawingmoney;
            //输出账户的钱
            System.out.println(account.name+"余额为:"+account.money);
            //输出用户拿到的钱
            System.out.println(Thread.currentThread().getName()+"取出"+nowmoney);
        }
    }

线程不安全，两个线程同时对一个资源操作时，出现余额为负数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center 1]  
**3.线程不安全**  
List是Java中比较常用的集合类，关于List接口有很多实现类，其中几个重点的实现是ArrayList、LinkedList和Vector

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center 2]  
之所以list集合没有10000个元素，有可能多个线程同时将线程名加入列表导致覆盖

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221021/e8b015bf84d445f7831e741bd133c562.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221021/62f2518c58244cef957df84e4a3638c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTg0Mjk1NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221021/b1ed77491ab1474ca8c8f4c67531e999.png