理解线程的安全问题

尝试加入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

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

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

原文：https://www.cnblogs.com/accurate-heizi/p/14399049.html