Android（java）学习笔记68：同步代码块的锁和同步方法的应用

  1 package cn.itcast_11;
  2
  3 public class SellTicket implements Runnable {
  4
  5     // 定义100张票
  6     private static int tickets = 100;
  7
  8     // 定义同一把锁
  9     private Object obj = new Object();
 10     private Demo d = new Demo();
 11
 12     private int x = 0;
 13
 14     //同步代码块用obj做锁
 15 //    @Override
 16 //    public void run() {
 17 //        while (true) {
 18 //            synchronized (obj) {
 19 //                if (tickets > 0) {
 20 //                    try {
 21 //                        Thread.sleep(100);
 22 //                    } catch (InterruptedException e) {
 23 //                        e.printStackTrace();
 24 //                    }
 25 //                    System.out.println(Thread.currentThread().getName()
 26 //                            + "正在出售第" + (tickets--) + "张票 ");
 27 //                }
 28 //            }
 29 //        }
 30 //    }
 31
 32     //同步代码块用任意对象做锁
 33 //    @Override
 34 //    public void run() {
 35 //        while (true) {
 36 //            synchronized (d) {
 37 //                if (tickets > 0) {
 38 //                    try {
 39 //                        Thread.sleep(100);
 40 //                    } catch (InterruptedException e) {
 41 //                        e.printStackTrace();
 42 //                    }
 43 //                    System.out.println(Thread.currentThread().getName()
 44 //                            + "正在出售第" + (tickets--) + "张票 ");
 45 //                }
 46 //            }
 47 //        }
 48 //    }
 49
 50     @Override
 51     public void run() {
 52         while (true) {
 53             if(x%2==0){
 54                 synchronized (SellTicket.class) {//synchronized (this)-------表示非同步方法的锁对象判定
 55                     if (tickets > 0) {
 56                         try {
 57                             Thread.sleep(100);
 58                         } catch (InterruptedException e) {
 59                             e.printStackTrace();
 60                         }
 61                         System.out.println(Thread.currentThread().getName()
 62                                 + "正在出售第" + (tickets--) + "张票 ");
 63                     }
 64                 }
 65             }else {
 66 //                synchronized (d) {
 67 //                    if (tickets > 0) {
 68 //                        try {
 69 //                            Thread.sleep(100);
 70 //                        } catch (InterruptedException e) {
 71 //                            e.printStackTrace();
 72 //                        }
 73 //                        System.out.println(Thread.currentThread().getName()
 74 //                                + "正在出售第" + (tickets--) + "张票 ");
 75 //                    }
 76 //                }
 77
 78                 sellTicket();
 79
 80             }
 81             x++;
 82         }
 83     }
 84
 85 //    private void sellTicket() {
 86 //        synchronized (d) {
 87 //            if (tickets > 0) {
 88 //            try {
 89 //                    Thread.sleep(100);
 90 //            } catch (InterruptedException e) {
 91 //                    e.printStackTrace();
 92 //            }
 93 //            System.out.println(Thread.currentThread().getName()
 94 //                        + "正在出售第" + (tickets--) + "张票 ");
 95 //            }
 96 //        }
 97 //    }
 98
 99     //如果一个方法一进去就看到了代码被同步了，那么我就再想能不能把这个同步加在方法上呢?
100 //     private synchronized void sellTicket() {
101 //            if (tickets > 0) {
102 //            try {
103 //                    Thread.sleep(100);
104 //            } catch (InterruptedException e) {
105 //                    e.printStackTrace();
106 //            }
107 //            System.out.println(Thread.currentThread().getName()
108 //                        + "正在出售第" + (tickets--) + "张票 ");
109 //            }
110 //    }
111
112     private static synchronized void sellTicket() {
113         if (tickets > 0) {
114         try {
115                 Thread.sleep(100);
116         } catch (InterruptedException e) {
117                 e.printStackTrace();
118         }
119         System.out.println(Thread.currentThread().getName()
120                     + "正在出售第" + (tickets--) + "张票 ");
121         }
122 }
123 }
124
125 class Demo {
126 }

 1 package cn.itcast_11;
 2
 3 /*
 4  * A:同步代码块的锁对象是谁呢?
 5  *         任意对象。
 6  *
 7  * B:同步方法的格式及锁对象问题?
 8  *         把同步关键字加在方法上。
 9  *
10  *         同步方法的锁对象是谁呢?
11  *             this
12  *
13  * C:静态方法及锁对象问题?
14  *         静态方法的锁对象是谁呢? （静态方法是随着类的加载而加载的，所以它的锁对象要先于它之前出现，只能是.class文件，逻辑上很好理解）15  *             类的字节码文件对象。
16  */
17 public class SellTicketDemo {
18     public static void main(String[] args) {
19         // 创建资源对象
20         SellTicket st = new SellTicket();
21
22         // 创建三个线程对象
23         Thread t1 = new Thread(st, "窗口1");
24         Thread t2 = new Thread(st, "窗口2");
25         Thread t3 = new Thread(st, "窗口3");
26
27         // 启动线程
28         t1.start();
29         t2.start();
30         t3.start();
31     }
32 }