解决线程安全问题

/**
 * 例子：创建三个窗口卖票，总票数为100张,使用实现Runnable接口的方式
 *
 * 1.问题：买票过程中出现了重票和错票 -->出现了线程的安全问题
 * 2.问题出现的原因：当某个线程操作的过程中，尚未操作完成时，其他线程参与进来，也来操作车票
 * 3.如何解决；当一个线程在操作票的时候，其他线程不能参与进来。知道线程a操作完票的时候。其他线程才可以开始操作票。
 * 这种情况即使线程a出现了阻塞，也不能被改变
 *
 * 方式一：同步代码块
 * syncronized(同步监视器){
 *     //需要被同步的代码
 * }
 * 方式二：同步方法（返回值的前面加synchronized）
 *      注意：非静态方法的锁是this,静态的方法的锁是class对象
 * 说明：
 * 1.操作共享数据的代码，即为需要被同步的代码
 * 2.共享数据：多个线程共同操作的变量：比如ticket就是共享数据
 * 3.同步监视器，俗称锁。任何一个类的对象都可以充当锁
 *      要求：多个线程必须共用同一把锁（同一个对象）
 *      补充：在实现Runnable接口船舰多线程的方式中，我们可以考虑使用this充当同步监视器。也可以考虑用当前类充当同步监视器
 *
 * 同步的方式解决了线程的安全问题 -- 好处
 * 操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低 --坏处
 * @author: qyx
 * @date: 2022-07-22 16:08
 * @desc:
 */

class Window1 implements Runnable{

    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {

            while (true) {
                synchronized(obj){
                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                }else break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window2 window2 = new Window2();
        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();

    }
}





/**
 *
 * 例子：创建三个窗口卖票，总票数为100张,使用继承Thread类的方式
 * @author: qyx
 * @date: 2022-07-22 12:31
 * @desc:
 */
class Window2 extends Thread{
    private  static int ticket = 100;
    private static Object object = new Object();
    @Override
    public void run() {

        while (true){
//            synchronized(object){
            synchronized(Window2.class){
                if(ticket > 0){
                    System.out.println(getName() + ": 买票，票号为：" + 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("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();

    }
}

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全的方式三：Lock锁   ---JDK5.0新增
 *
 * 1.面试题：synchronized和lock的异同
 * 相同：二者都可以解决线程安全问题
 * 不同：synchronized机制在执行完相应的代码块hou自动释放同步监视器
 *      lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock）
 *
 * 2.优先使用的顺序
 * Lock -> 同步代码块 ->同步方法
 * @author: qyx
 * @date: 2022-07-23 18:47
 * @desc:
 */

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentranLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try{
                //2.调用锁定方法lock()
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                }else break;
            }finally {
                //3.调用解锁的方法
                lock.unlock();
            }
        }
    }
}
public class LockTest {

    public static void main(String[] args) {
        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}