多线程学习--synchronized锁重入

Dear 丶 2023-10-27 07:07 218阅读 0赞 
  1. synchronized锁重入：关键字synchronized拥有锁重入的功能，就是在使用synchronized时候，当一个线程得到一个对象锁后，在此请求此对象锁时是可以再次获取到该对象锁的，这说明了一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。

可重入锁概念：自己可以再次获取自己内部锁。比如由1条线程获取了某个对象锁，此时这个对象锁还没有释放，当其再次想获取这个对象锁的时候还是可以获取的，如不无法获取，就会造成死锁。

可重入锁也支持父子类继承的。

案例：

  1. public class Service {
  3.     public synchronized void service1(){
  4.         System.out.println("service1");
  5.         service2();
  6.     }
  7.     public synchronized void service2(){
  8.         System.out.println("service2");
  9.         service3();
  10.     }
  11.     public synchronized void service3(){
  12.         System.out.println("service3");
  13.     }
  15.     public static void main(String[] args) {
  16.         Service service=new Service();
  17.         new Thread(() ->{
  19.             service.service1();
  21.         }).start();
  22.     }
  23. }

结果：

  1. service1
  2. service2
  3. service3

继承性：

  1. public class Main {
  2.     protected int i = 10;
  4.     synchronized public void operateIinMain() {
  5.         try {
  6.             i--;
  7.             System.out.println("main print i=" + i);
  8.             Thread.sleep(100);
  9.         } catch (InterruptedException e) {
  10.             e.printStackTrace();
  11.         }
  12.     }
  13. }
  15. public class Sub extends Main {
  16.     synchronized public void operateIinSub() {
  17.         try {
  18.             while (i > 0) {
  19.                 i--;
  20.                 System.out.println("sub print i=" + i);
  21.                 Thread.sleep(100);
  22.                 this.operateIinMain();
  23.             }
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  30.     public static void main(String[] args) {
  31.         Sub sub = new Sub();
  32.         new Thread(() ->{
  34.             sub.operateIinSub();
  36.         }).start();
  37.     }
  38. }

结果：

  1. sub print i=9
  2. main print i=8
  3. sub print i=7
  4. main print i=6
  5. sub print i=5
  6. main print i=4
  7. sub print i=3
  8. main print i=2
  9. sub print i=1
  10. main print i=0

发表评论

表情：
评论列表 （有 0 条评论，218人围观）

还没有评论，来说两句吧...

相关阅读

    相关 多线程锁-可重入锁

    3.4 可重入锁（递归锁） 3.4.1 概念说明 是指在同一线程在外层方法获取到锁的时侯，在进入该线程的内层方法会自动获取锁（前提，锁对 象的是同一个对象），不会因为之前

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 45 阅读

    相关 Synchronize锁重入

    Synchronize锁重入 拥有锁重入的功能 就是在使用synchronize时，当一个线程得到了一个对象的锁之后 再次，请求该对象时，可以再次得到该对象的锁

    Bertha 。Bertha 。/ 0 赞/ 281 阅读