线程的安全问题的解决方法-锁

怼烎@ 2023-10-05 19:37 8阅读 0赞

## 理解线程的安全问题 ##

尝试加入sleep

package new1;
    
    public class demo3 {
        
        public static void main(String[] args) {
        
            window t1 = new window();
            window t2 = new window();
            window t3 = new window();
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    
    }
    
    class window extends Thread{
        
        private  static int ticket = 5;
    
        public void run(){
        
    
            while(true){
        
                if(ticket>0){
        
                    try {
        
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
                    System.out.println(getName()+"卖票，票号为："+ticket);
                    ticket--;
                }else{
        
                    break;
                }
            }
        }
    }

结果

窗口1卖票，票号为：5
    窗口3卖票，票号为：4
    窗口2卖票，票号为：4
    窗口1卖票，票号为：2
    窗口2卖票，票号为：1
    窗口3卖票，票号为：1
    窗口1卖票，票号为：-1

假设还剩一张票，因为一个线程进入循环但出现阻塞，使得在它没有减少票数的时候其他线程加入其中，其他出现错票-1

##### 若是加大重票概率则改为 #####

while(true){
        
                if(ticket>0){
        
                    
    
                    System.out.println(getName()+"卖票，票号为："+ticket);
                    
                    try {
        
                        Thread.sleep(100);  //因为阻塞过程中票数还没减少，另一个线程就进来并输出了票数被阻塞
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    
                    ticket--;
                }else{
        
                    break;
                }
            }

##### 如何解决安全问题： #####

当一个线程在操作ticket的时候，其他线程不能参与进来。知道线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

方式一：同步代码块

synchronized(同步监视器)\{

//需要被同步的代码

说明：

1.  操作共享数据的代码，即为需要被同步的代码。
2.  共享操作：多个线程共同操作的变量。比如：ticket
3.  同步监视器，俗称：锁。\*\*任何一个类的对象，都可以充当锁

##### 错误版本 #####

package new1;
    
    public class demo3 {
        
        public static void main(String[] args) {
        
            window t1 = new window();  //这是重点，对比Runnable
            window t2 = new window();
            window t3 = new window();
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    
    }
    
    class window extends Thread{
        
        private  static int ticket = 5;
        Object obj = new Object();  
    
        public void run(){
        
    
            while(true){
        
                synchronized (obj) {
          //需要改为private static Object obj = new Object();
                    //这里改为synchronized(this)也不行
                    //但是可以改为synchronized(window.class)这是唯一的
                    if (ticket > 0) {
        
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(getName() + "卖票，票号为：" + ticket);
                        ticket--;
                    } else {
        
                        break;
                    }
                }
            }
        }
    }

结果，错误时因为锁的对象不是共享而是一人新建了一把锁

窗口1卖票，票号为：5
    窗口2卖票，票号为：5
    窗口3卖票，票号为：5
    窗口2卖票，票号为：2
    窗口1卖票，票号为：2
    窗口3卖票，票号为：2
    窗口2卖票，票号为：-1

##### 正确方法 #####

package new1;
    
    
    public class demo4 {
        
        public static void main(String[] args) {
        
           Window1 w = new Window1(); //此时只造了一个对象，对比Thread
    
           Thread t1 = new Thread(w);  //一个对象放到三个构造器中，相当于三个线程用的同一个对象，所以ticket不用担心是总数是300，也不用担心obj1被建立三次
           Thread t2 = new Thread(w);
           Thread t3 = new Thread(w);
    
           t1.setName("窗口一");
           t2.setName("窗口二");
           t3.setName("窗口三");
    
           t1.start();
           t2.start();
           t3.start();
        }
    }
    //创建一个实现了Runnable接口的类
    class Window1 implements Runnable{
        
        
        private int ticket = 5;
        Object obj1 = new Object();
        
        public void run(){
        
           while(true){
        
               synchronized (obj1) {
        
                   //这里可以改为synchronized(this)。此时的this唯一的window1的对象，就可以不new新对象
                   if (ticket > 0) {
        
    
                       try {
        
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
        
                           e.printStackTrace();
                       }
    
                       System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                       ticket--;
                   } else {
        
                       break;
                   }
               }
           }
        }
    }

结果

窗口一卖票，票号为：5
    窗口一卖票，票号为：4
    窗口一卖票，票号为：3
    窗口一卖票，票号为：2
    窗口一卖票，票号为：1

下一节学习方式二：同步方法