Java Synchronized同步锁练习 (2024.8.12)

        错误示范

package SynchronizedExercise20240812;

public class SynchronizedExercise1Error {
    // 错误的写法
    public static void main(String[] args) {
        /* 需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票 */

        SellTicketError st = new SellTicketError();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

        // 发现有两个问题：1.不同的窗口在卖同一张票
        //                2.有窗口卖了不存在的票

        // 问题原因：线程执行的随机性导致的，窗口线程在卖票的时候丢失了CPU执行权（如sleep方法），导致出现了问题
    }
}

        SellStickError

package SynchronizedExercise20240812;

public class SellTicketError implements Runnable{
    // 这是错误的写法
    static int tickets =  100;
    @Override
    public void run() {
        while(true) {
            if (tickets <= 0) {
                break;
            }else {
                try{
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                tickets--;
                System.out.println(Thread.currentThread().getName() + ": 正在卖第" + (100 - tickets) + "张票");
            }
        }
    }
}

        

        正确示范

        SynchronizedExercise2

package SynchronizedExercise20240812;

public class SynchronizedExercise2 {
    public static void main(String[] args) {
        // 数据安全问题出现的条件
        // 1.具备多线程环境（线程执行的随机性导致，一条线程并未执行完毕，在执行过程中丢失了CPU执行权，导致问题）
        // 2.具有共享的数据
        // 3.有多条语句操作共享数据

        // 用同步代码块解决数据安全问题
        // 思想：将多条语句操作共享数据的代码锁起来，让同一时刻只能有一个线程执行
        // Java提供了同步代码块方式来解决此类问题

        // synchronized(任意对象) {
        //      多条语句操作共享数据的代码
        // }

        SellTicketsPro st1 = new SellTicketsPro();
        SellTicketsPro st2 = new SellTicketsPro();
        SellTicketsPro st3 = new SellTicketsPro();

        Thread thread1 = new Thread(st1, "窗口1");
        Thread thread2 = new Thread(st2, "窗口2");
        Thread thread3 = new Thread(st3, "窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

        SellTicketsPro

package SynchronizedExercise20240812;

public class SellTicketsPro implements Runnable{
    private static int tickets = 100; // 必须用static修饰票数：即使有多个SellTickets对象，也是共享这100张票
    private static final Object lock = new Object(); // 必须用static修饰锁对象，即使有多个SellTickets对象，也共享这一把锁
    @Override
    public void run() {
        while(true) {
            synchronized (lock) {
                // 将操作共享数据的代码用synchronized锁起来
                // 假如Thread1抢到CPU资源，那么就进入锁，并且将synchronized锁起来
                if (tickets > 0) {
                    try{
                        Thread.sleep(100);
                        // Thread1就算进入sleep状态，因为存在锁，CPU资源也不会被其他线程抢走
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + (100 - tickets) + "张票");
                } else {
                    return;
                }
            }
            // Thread1到此处才会释放锁，然后又回到线程抢占CPU资源的操作
        }
    }
}

         SynchronizedExercise3

package SynchronizedExercise20240812;

public class SynchronizedExercise3 {
    public static void main(String[] args) {
        // 同步方法解决数据安全问题
        // 同步方法：将synchronized关键字加到方法上，使得该方法变成同步方法，其作用和同步代码块是相同的
        // 修饰符 synchronized 返回值类型 方法名(参数) {
        //        方法体;
        // }

        // 同步方法的方法锁的对象————>this
        SellTicketMethod stm = new SellTicketMethod();

        Thread thread1 = new Thread(stm, "窗口1");
        Thread thread2 = new Thread(stm, "窗口2");
        Thread thread3 = new Thread(stm, "窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

        SellTicketsMethod

package SynchronizedExercise20240812;

public class SellTicketMethod implements Runnable {
    private static int tickets = 100;
    @Override
    public void run() {
        while (true) {
            boolean flag = synchronizedMethod();
            if (!flag) {
                return;
            }
        }
    }

    public synchronized boolean synchronizedMethod() {
        if (tickets <= 0) {
            return false;
        }
        try{
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tickets--;
        System.out.println(Thread.currentThread().getName() + ": 正在卖第" + (100 - tickets) + "张票");
        return true;
    }
}