解决线程安全问题的两种办法

package com.xt.java;

/**
 * 创建3个窗口卖票，总票数为100张  使用实现Runnable接口的方式
 * 问题一：买票过程中，出现了重票、错票-->出现了线程安全问题
 * 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其它线程参与进来，也操作车票
 * 如何解决：当一个线程a在操作ticket时，其它线程不能参与进来。直到a操作完ticket后，其它线程才
 *         开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
 * 在Java中，我们通过同步机制，来解决线程的安全问题。
 * 方式一：同步代码块：
 *      synchronized(同步监视器){
 *          //需要被同步的代码
 *      }
 *      说明：操作共享数据的代码，即为需要被同步的代码-->不能包括多了，也不能包括少了
 *      1.共享数据：多个线程共同操作的变量。比如：ticket
 *      2.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
 *        要求：多个线程必须共用同一把锁。
 *      补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this来充当同步监视器
 * 方式二：同步方法：
 *      如果操作共享数据的代码完整地声明在一个方法中，我们不妨将这个方法声明为同步的。
 * 同步的方式：解决了线程安全问题----好处
 *          操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。--局限性
 *
 * @author tyl
 * @creat 2022-03-26-14:44
 */
class Window1 implements Runnable{
    private int ticket=100;
//    Object obj=new Object();   //注意位置
    @Override
    public void run() {
        // Object obj=new Object();   //注意位置，放在此处，锁不唯一，故不安全
        while(true){
            //synchronized (obj){
            synchronized (this){ //此时的this:唯一的window1的对象
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+": 卖票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }

        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w=new Window1();

        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package com.xt.java;

/**
 * @author tyl
 * @creat 2022-04-10-16:48
 *
 * 例子，创建3个窗口卖票，总票数为100，使用继承Thread类的方式。
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 * 说明：在继承Thread创建多线程的方式中，慎用this充当同步监视器。考虑使用当前类充当同步监视器。
 *
 */
class Window2 extends Thread{
    private static int ticket=100;
    static Object obj=new Object();   //注意用static解决同一把锁的问题
    @Override
    public void run() {

        while(true){
            //正确的
            //synchronized(obj){
            synchronized (Window2.class){ //Class clazz=Window2.class  (类其实可以作为一个对象出现) Window2.class只会加载1次
                //synchronized(this){   //错误的,当前对象不唯一（继承方式）
                if (ticket>0){
                    System.out.println(getName()+"：卖票，票号为"+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }

        }

    }
}
public class WindowTest2{
    public static void main(String[] args) {
        Window2 w1=new Window2();
        Window2 w2=new Window2();
        Window2 w3=new Window2();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }


}

package com.xt.java;

/**
 * @author tyl
 * @creat 2022-04-10-17:53
 *
 * 使用同步方法解决实现Runnable接口的线程安全问题
 * 关于同步方法的总结：
 * 1.同步方法仍然涉及到同步监视器，只是不需要我们显式地声明。
 * 2.非静态的同步方法，同步监视器是this
 *   静态的同步方法，同步监视器是：当前类本身
 */
class Window implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while(true){
            show();
        }
    }
    public synchronized void show(){  //同步监视器：this

            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"：卖票，票号为"+ticket);
                ticket--;
            }

    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Window w=new Window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }

}

package com.xt.java;
/**
 * @author tyl
 * @creat 2022-04-10-18:09
 *
 * 使用同步方法解决继承Thread类方式的线程安全问题
 */
class Window4 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {

        while(true){
           show();
        }
    }
    private static synchronized void show(){   //同步监视器：Window4.class
//    private synchronized void show(){  //同步监视器：w1、w2、w3 -->不唯一,故此种解决方式是错误的
        if (ticket>0){
            System.out.println(Thread.currentThread().getName()+"：卖票，票号为"+ticket);
            ticket--;
        }
    }
}
public class WindowTest4{
    public static void main(String[] args) {
        Window4 w1=new Window4();
        Window4 w2=new Window4();
        Window4 w3=new Window4();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }


}