为了模拟真实环境，代码加入延时

1. package com.kxg_09;
   
2. 
   
3. public class SellTicekt implements Runnable {
   
4.         private int ticket = 100;
   
5. 
   
6.         @Override
   
7.         public void run() {
   
8.                 while (true) {
   
9.                         if (ticket > 0) {
   
10.                                 try {
    
11.                                         Thread.sleep(100);
    
12.                                 } catch (InterruptedException e) {
    
13.                                         e.printStackTrace();
    
14.                                 }
    
15.                                 System.out.println(Thread.currentThread().getName() + "正在出售第"
    
16.                                                 + (ticket--) + "张票");
    
17.                         }
    
18.                 }
    
19.         }
    
20. }

复制代码

1. package com.kxg_09;
   
2. 
   
3. /*
   
4. * 实现Runnable接口
   
5. */
   
6. public class SellTicketDemo {
   
7.         public static void main(String[] args) {
   
8.                 // 创建自定义类对象
   
9.                 SellTicekt st = new SellTicekt();
   
10. 
    
11.                 // 创建线程
    
12.                 Thread t1 = new Thread(st);
    
13.                 Thread t2 = new Thread(st);
    
14. 
    
15.                 // 设置线程名称
    
16.                 t1.setName("窗口1");
    
17.                 t2.setName("窗口2");
    
18. 
    
19.                 // 启动线程
    
20.                 t1.start();
    
21.                 t2.start();
    
22.         }
    
23. }

复制代码

此时运行程序就会出现相同票卖多次和出现负数票的情况

1.相同的票卖了多次
    CPU的一次操作必须是原子性的
2.出现负数票
    线程的随机性和延迟导致的

解决方式1：同步代码块
把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行

1. package com.kxg_09;
   
2. 
   
3. /*
   
4. * synchronized(对象){
   
5. *                 代码;
   
6. * }
   
7. *
   
8. * 注意：同步代码块可以解决安全问题的根本原因在对象上，该对象如果锁一样的功能，别的线程不能进入。
   
9. *                  这个对象可以是任意对象，最好是用本身this作为这个对象。
   
10. *
    
11. */
    
12. public class SellTicekt implements Runnable {
    
13.         private int ticket = 100;
    
14. 
    
15.         @Override
    
16.         public void run() {
    
17.                 while (true) {
    
18.                         synchronized (this) {
    
19.                                 if (ticket > 0) {
    
20.                                         try {
    
21.                                                 Thread.sleep(100);
    
22.                                         } catch (InterruptedException e) {
    
23.                                                 e.printStackTrace();
    
24.                                         }
    
25.                                         System.out.println(Thread.currentThread().getName()
    
26.                                                         + "正在出售第" + (ticket--) + "张票");
    
27.                                 }
    
28.                         }
    
29.                 }
    
30.         }
    
31. }

复制代码

方式2：同步方法

1. package com.kxg_09;
   
2. 
   
3. /*
   
4. * synchronized关键字修饰方法
   
5. * 锁对象是this
   
6. */
   
7. public class SellTicekt implements Runnable {
   
8.         private int ticket = 100;
   
9. 
   
10.         @Override
    
11.         public synchronized void run() {
    
12.                 while (true) {
    
13.                         if (ticket > 0) {
    
14.                                 try {
    
15.                                         Thread.sleep(100);
    
16.                                 } catch (InterruptedException e) {
    
17.                                         e.printStackTrace();
    
18.                                 }
    
19.                                 System.out.println(Thread.currentThread().getName() + "正在出售第"
    
20.                                                 + (ticket--) + "张票");
    
21.                         }
    
22.                 }
    
23.         }
    
24. }

复制代码

同步特点：
    前提：多个线程
    解决问题注意：多个线程使用的是同一个锁对象
同步好处：
    同步解决了多线程的安全问题
同步的弊端：
    当线程很多时，因为每个线程都会去判断同步上的锁，很消耗资源，降低程序的运行效率

好用功啊，比老师的视频代码你都给练习了

向你致敬，实在是太用功了