1. 
   
2. 判断一个程序是否会有线程安全问题的标准:
   
3.           * A:是否是多线程环境
   
4.           * B:是否有共享数据
   
5.           * C:是否有多条语句操作共享数据
   
6. 
   
7. 
   
8. * 接下来才是我们要想想如何解决问题呢?
   
9. * A和B的问题我们改变不了，我们只能想办法去把C改变一下。
   
10. * 思想：
    
11. *                 把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行。
    
12. * 问题是我们不知道怎么包啊?其实我也不知道，但是Java给我们提供了：同步机制。
    
13. *
    
14. * 同步代码块：//这里的对象可以是任意对象
    
15. *                 synchronized(对象){
    
16. *                         需要同步的代码;
    
17. *                 }
    
18. *
    
19. *                 A:对象是什么呢?
    
20. *                         我们可以随便创建一个对象试试。
    
21.             处理线程安全问题的方法:
    
22.                 Object obj = new Object();
    
23.                         synchronized(obj){
    
24.                         需要同步的代码;
    
25.                 }
    
26. *                 B:需要同步的代码是哪些呢?
    
27. *                         把多条语句操作共享数据的代码的部分给包起来
    
28. *
    
29. *                 注意：
    
30. *                         同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
    
31. *                         多个线程必须是同一把锁。
    
32. */
    
33. 以火车卖票为例:
    
34. package cn.itcast_10;
    
35. /*
    
36. * 举例：
    
37. *                 火车上厕所。
    
38. *
    
39. * 同步的特点：
    
40. *                 前提：
    
41. *                         多个线程
    
42. *                解决问题的时候要注意：
    
43. *                        多个线程使用的是同一个锁对象
    
44. * 同步的好处
    
45. *                同步的出现解决了多线程的安全问题。
    
46. * 同步的弊端
    
47. *                当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低    程序的运行效率。
    
48. */
    
49. public class SellTicketDemo {
    
50.         public static void main(String[] args) {
    
51.                 // 创建资源对象
    
52.                 SellTicket st = new SellTicket();
    
53.                 // 创建三个线程对象
    
54.                 Thread t1 = new Thread(st, "窗口1");
    
55.                 Thread t2 = new Thread(st, "窗口2");
    
56.                 Thread t3 = new Thread(st, "窗口3");
    
57.                 // 启动线程
    
58.                 t1.start();
    
59.                 t2.start();
    
60.                 t3.start();
    
61.         }
    
62. }
    
63. package cn.itcast_10;
    
64. public class SellTicket implements Runnable {
    
65.         // 定义100张票
    
66.         private int tickets = 100;
    
67.         // 定义同一把锁
    
68.         private Object obj = new Object();
    
69.         @Override
    
70.         public void run() {
    
71.                 while (true) {
    
72.                         // t1,t2,t3都能走到这里
    
73.                         // 假设t1抢到CPU的执行权，t1就要进来
    
74.                         // 假设t2抢到CPU的执行权，t2就要进来,发现门是关着的，进不去。所以就等着。
    
75.                         // 门(开,关)
    
76.                         synchronized (obj) { // 发现这里的代码将来是会被锁上的，所以t1进来后，就锁了。(关)
    
77.                                 if (tickets > 0) {
    
78.                                         try {
    
79.                                                 Thread.sleep(100); // t1就睡眠了
    
80.                                         } catch (InterruptedException e) {
    
81.                                                 e.printStackTrace();
    
82.                                         }
    
83.                                         System.out.println(Thread.currentThread().getName()
    
84.                                                         + "正在出售第" + (tickets--) + "张票 ");
    
85.                                         //窗口1正在出售第100张票
    
86.                                 }
    
87.                         } //t1就出来可，然后就开门。(开)
    
88.                 }
    
89.         }
    
90. }
    
91. 
    

复制代码

收藏; ,,,,,,,,,