Java多线程——线程八锁案例分析

Java多线程——线程八锁案例分析

摘要：本文主要学习了多线程并发中的一些案例。

部分内容来自以下博客：

https://blog.csdn.net/dyt443733328/article/details/80019352

多线程的八个案例

通过分析代码，推测打印结果，并运行代码进行验证。

1）两个线程调用同一个对象的两个同步方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number number = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public synchronized void getOne() {
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 one
 two

结果分析：

被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。

2）新增Thread.sleep()给某个方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number number = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 // 等待一秒。
 one
 two

结果说明：

被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行，第二个方法只有在第一个方法执行完释放锁之后才能执行。

3）新增一个线程调用新增的一个普通方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number number = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getTwo();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getThree();
             }
         }).start();
     }
 }

 class Number {
     public synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }

     public void getThree() {
         System.out.println("three");
     }
 }

运行结果如下：

 three
 // 等待一秒。
 one
 two

结果说明：

新增的方法没有被synchronized修饰，不是同步方法，不受锁的影响，所以不需要等待。其他线程共用了一把锁，所以还需要等待。

4）两个线程调用两个对象的同步方法，其中一个方法有Thread.sleep()

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number numberOne = new Number();
         Number numberTwo = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberOne.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberTwo.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 two
 // 等待一秒。
 one

结果说明：

被synchronized修饰的方法，锁的对象是方法的调用者。因为用了两个对象调用各自的方法，所以两个方法的调用者不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

5）将有Thread.sleep()的方法设置为static方法，并且让两个线程用同一个对象调用两个方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number number = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public static synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 two
 // 等待一秒。
 one

结果说明：

被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法锁的对象不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

6）将两个方法均设置为static方法，并且让两个线程用同一个对象调用两个方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number number = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 number.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public static synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public static synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 // 等待一秒。
 one
 two

结果说明：

被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，所以两个方法用的是同一个锁，后调用的方法需要等待先调用的方法。

7）将两个方法中有Thread.sleep()的方法设置为static方法，另一个方法去掉static修饰，让两个线程用两个对象调用两个方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number numberOne = new Number();
         Number numberTwo = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberOne.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberTwo.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public static synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 two
 // 等待一秒。
 one

结果说明：

被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。即便是用同一个对象调用两个方法，锁的对象也不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

8）将两个方法均设置为static方法，并且让两个线程用同一个对象调用两个方法

代码如下：

 public class Demo {
     public static void main(String[] args) {
         Number numberOne = new Number();
         Number numberTwo = new Number();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberOne.getOne();
             }
         }).start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 numberTwo.getTwo();
             }
         }).start();
     }
 }

 class Number {
     public static synchronized void getOne() {
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("one");
     }

     public static synchronized void getTwo() {
         System.out.println("two");
     }
 }

运行结果如下：

 // 等待一秒。
 one
 two

结果说明：

被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，即便用了两个不同的对象调用方法，两个方法用的还是同一个锁，后调用的方法需要等待先调用的方法。

总结

一个类里面如果有多个synchronized方法，在使用同一个对象调用的前提下，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其他的线程都只能等待，换句话说，某一时刻内，只能有唯一一个线程去访问这些synchronized方法。

锁的是当前对象this，被锁定后，其他线程都不能进入到当前对象的其他的synchronized方法。

加个普通方法后发现和同步锁无关。

换成静态同步方法后，情况又变化。

所有的非静态同步方法用的都是同一把锁：实例对象本身。

也就是说如果一个对象的非静态同步方法获取锁后，该对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是其他对象的非静态同步方法因为跟该对象的非静态同步方法用的是不同的锁，所以毋须等待该对象的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁：类对象本身。

这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间不会有竞争条件。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个对象的静态同步方法，还是其他对象的静态同步方法，只要它们属于同一个类的对象，那么就需要等待当前正在执行的静态同步方法释放锁。