1、多窗口卖票

  • 三个窗口卖100张票 ```json public class Main { public static void main(String[] args) {
  1.     MyRunnable myRunnable = new MyRunnable();
  3.     new Thread(myRunnable).start();
  4.     new Thread(myRunnable).start();
  5.     new Thread(myRunnable).start();
  6. }
  8. static class MyRunnable implements Runnable {
  10.     private int ticket = 100;
  12.     @Override
  13.     public void run() {
  15.         while (true) {
  16.             if (ticket > 0) {
  17.                 try {
  18.                     Thread.sleep(10);
  19.                 } catch (InterruptedException e) {
  20.                     e.printStackTrace();
  21.                 }
  22.                 System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
  23.                 ticket--;
  24.             } else {
  25.                 System.out.println(Thread.currentThread().getName() + "卖完了");
  26.                 break;
  27.             }
  28.         }
  30.     }
  31. }

}

  2. - CPU在不同线程间切换，共享数据不是安全的；会出现卖了同一张票、不存在的票问题
  3. - 最终原因：CPU在三个线程间轮流切换执行（例如CPU先执行线程1，执行到某一行代码，CPU又去执行了线程2，这期间的共享数据就是不准确的）<br />
  4. ```json
  5. Thread-0正在卖第3张票
  6. Thread-2正在卖第2张票
  7. Thread-1正在卖第2张票
  8. Thread-1卖完了
  9. Thread-2正在卖第0张票
  10. Thread-2卖完了
  11. Thread-0正在卖第-1张票
  12. Thread-0卖完了

  • 这些线程安全问题，可以通过添加synchronized同步来解决

    2、同步代码块

  • 测试类 ```json public class Main { public static void main(String[] args) {

  1.     MyRunnable runnable = new MyRunnable();
  2.     new Thread(runnable, "SyncThread1").start();
  3.     new Thread(runnable, "SyncThread2").start();
  5.     /**
  6.      SyncThread1:0
  7.      SyncThread1:1
  8.      SyncThread1:2
  9.      SyncThread1:3
  10.      SyncThread1:4
  11.      SyncThread2:5
  12.      SyncThread2:6
  13.      SyncThread2:7
  14.      SyncThread2:8
  15.      SyncThread2:9
  16.      */
  18.     // 使用的不同MyRunnable对象，所以不能同步
  19.     MyRunnable r1 = new MyRunnable();
  20.     MyRunnable r2 = new MyRunnable();
  21.     new Thread(r1, "SyncThread1").start();
  22.     new Thread(r2, "SyncThread2").start();
  24.     /**
  25.      SyncThread1:1
  26.      SyncThread2:0
  27.      SyncThread2:3
  28.      SyncThread1:2
  29.      SyncThread2:4
  30.      SyncThread1:5
  31.      SyncThread1:6
  32.      SyncThread2:6
  33.      SyncThread2:7
  34.      SyncThread1:7
  35.      */
  36. }
  38. static class MyRunnable implements Runnable {
  39.             // 此处是静态变量，归类所有，所有的实例访问是同一个
  40.     public static int count;
  42.     public MyRunnable() {
  43.         count = 0;
  44.     }
  46.     public void run() {
  47.         // 此处锁的是MyRunnable对象
  48.         synchronized (this) {
  49.             for (int i = 0; i < 5; i++) {
  50.                 try {
  51.                     System.out.println(Thread.currentThread().getName() + ":" + (count++));
  52.                     Thread.sleep(100);
  53.                 } catch (InterruptedException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.         }
  58.     }
  59. }

}

  2. - 结论
  3.    - synchronized (this)：锁的是当前MyRunnable对象
  4.    - 例子一结论：一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞<br />
  5.    - 例子二结论：synchronized锁定的是对象，这时会有两把锁分别锁定r1对象和r2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行<br />
  7. <a name="1cAMQ"></a>
  8. ### 3、同步非静态方法
  10. - synchronized修饰一个非静态方法，锁的是Runnable的一个对象<br />
  11. - synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数<br />
  12. ```json
  13. public class Main {
  14.     public static void main(String[] args) {
  17.         MyRunnable runnable = new MyRunnable();
  18.         new Thread(runnable, "SyncThread1").start();
  19.         new Thread(runnable, "SyncThread2").start();
  21.         /**
  22.          SyncThread1:0
  23.          SyncThread1:1
  24.          SyncThread1:2
  25.          SyncThread1:3
  26.          SyncThread1:4
  27.          SyncThread2:5
  28.          SyncThread2:6
  29.          SyncThread2:7
  30.          SyncThread2:8
  31.          SyncThread2:9
  32.          */
  34.         // 使用的不同MyRunnable对象，所以不能同步
  35.         MyRunnable r1 = new MyRunnable();
  36.         MyRunnable r2 = new MyRunnable();
  37.         new Thread(r1, "SyncThread1").start();
  38.         new Thread(r2, "SyncThread2").start();
  40.         /**
  41.          SyncThread2:0
  42.          SyncThread1:1
  43.          SyncThread1:2
  44.          SyncThread2:2
  45.          SyncThread2:3
  46.          SyncThread1:3
  47.          SyncThread1:4
  48.          SyncThread2:5
  49.          SyncThread1:6
  50.          SyncThread2:6
  51.          */
  52.     }
  54.     static class MyRunnable implements Runnable {
  56.         public static int count;
  58.         public MyRunnable() {
  59.             count = 0;
  60.         }
  62.         public synchronized void run() {
  63.             // 此处锁的是MyRunnable对象
  64.             for (int i = 0; i < 5; i++) {
  65.                 try {
  66.                     System.out.println(Thread.currentThread().getName() + ":" + (count++));
  67.                     Thread.sleep(100);
  68.                 } catch (InterruptedException e) {
  69.                     e.printStackTrace();
  70.                 }
  71.             }
  72.         }
  73.     }
  74. }

  • 结论

    • synchronized void run()：锁的是当前MyRunnable对象
    • 例子一结论：一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞
    • 例子二结论：synchronized锁定的是对象，这时会有两把锁分别锁定r1对象和r2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行

      4、同步静态方法

  • synchronized修饰一个静态方法，锁的是Runnable类

  • thread1和thread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以thread1和thread2相当于用了同一把锁

    1. public class Main {
    2.   public static void main(String[] args) {
    4.       MyRunnable runnable = new MyRunnable();
    5.       new Thread(runnable, "SyncThread1").start();
    6.       new Thread(runnable, "SyncThread2").start();
    8.       /**
    9.        SyncThread1:0
    10.        SyncThread1:1
    11.        SyncThread1:2
    12.        SyncThread1:3
    13.        SyncThread1:4
    14.        SyncThread2:5
    15.        SyncThread2:6
    16.        SyncThread2:7
    17.        SyncThread2:8
    18.        SyncThread2:9
    19.        */
    21.       MyRunnable r1 = new MyRunnable();
    22.       MyRunnable r2 = new MyRunnable();
    23.       new Thread(r1, "SyncThread1").start();
    24.       new Thread(r2, "SyncThread2").start();
    26.       /**
    27.        SyncThread1:0
    28.        SyncThread1:1
    29.        SyncThread1:2
    30.        SyncThread1:3
    31.        SyncThread1:4
    32.        SyncThread2:5
    33.        SyncThread2:6
    34.        SyncThread2:7
    35.        SyncThread2:8
    36.        SyncThread2:9
    37.        */
    38.   }
    40.   static class MyRunnable implements Runnable {
    42.       public static int count;
    44.       public MyRunnable() {
    45.           count = 0;
    46.       }
    48.       public  void run() {
    49.           method();
    50.       }
    52.       // 此处锁的是MyRunnable类，包含所有类实例
    53.       private synchronized static void method() {
    55.           for (int i = 0; i < 5; i++) {
    56.               try {
    57.                   System.out.println(Thread.currentThread().getName() + ":" + (count++));
    58.                   Thread.sleep(100);
    59.               } catch (InterruptedException e) {
    60.                   e.printStackTrace();
    61.               }
    62.           }
    63.       }
    64.   }
    65. }

  • 结论

    • r1和r2是MyRunnable的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁

5、同步类

  • synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁
    ```json public class Main { public static void main(String[] args) {

// MyRunnable runnable = new MyRunnable(); // new Thread(runnable, “SyncThread1”).start(); // new Thread(runnable, “SyncThread2”).start();

  1.     /**
  2.      SyncThread1:0
  3.      SyncThread1:1
  4.      SyncThread1:2
  5.      SyncThread1:3
  6.      SyncThread1:4
  7.      SyncThread2:5
  8.      SyncThread2:6
  9.      SyncThread2:7
  10.      SyncThread2:8
  11.      SyncThread2:9
  12.      */
  14.     MyRunnable r1 = new MyRunnable();
  15.     MyRunnable r2 = new MyRunnable();
  16.     new Thread(r1, "SyncThread1").start();
  17.     new Thread(r2, "SyncThread2").start();
  19.     /**
  20.      SyncThread1:0
  21.      SyncThread1:1
  22.      SyncThread1:2
  23.      SyncThread1:3
  24.      SyncThread1:4
  25.      SyncThread2:5
  26.      SyncThread2:6
  27.      SyncThread2:7
  28.      SyncThread2:8
  29.      SyncThread2:9
  30.      */
  31. }
  33. static class MyRunnable implements Runnable {
  35.     public static int count;
  37.     public MyRunnable() {
  38.         count = 0;
  39.     }
  41.     public void run() {
  42.         synchronized(MyRunnable.class){
  43.             for (int i = 0; i < 5; i++) {
  44.                 try {
  45.                     System.out.println(Thread.currentThread().getName() + ":" + (count++));
  46.                     Thread.sleep(100);
  47.                 } catch (InterruptedException e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }

}

  2. <a name="c3d3b779"></a>
  3. ### 5、synchronized使用限制
  5. -  synchronized关键字不能继承<br />
  6. - 如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以<br />
  7. ```json
  8. class Parent {
  9.   public synchronized void method() { }
  10. }
  11. class Child extends Parent {
  12.   public synchronized void method() { }
  13. }

  • 当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了

    1. class Parent {
    2. public synchronized void method() {  }
    3. }
    4. class Child extends Parent {
    5. public void method() { super.method();  }
    6. }

  • 在定义接口方法时不能使用synchronized关键字

    1. interface MyClick{
    2.   // 此处不允许使用修饰符synchronized
    3.   synchronized void add();
    4. }

  • 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步