JUC——8锁问题

文章目录

- 问题一和问题二：
- 问题三：
- 问题四：
- 问题五和问题六：
- 问题七和问题八：
- 总结

八锁现象是在多线程编程中经常遇到的一种情况，指的是在使用synchronized关键字进行同步时可能出现的不同的执行顺序。下面对问题一到问题八进行总结：

问题一和问题二：

两个线程分别调用Phone类的senMesg()和call()方法。
根据synchronized关键字的特性，锁的是方法的调用者，这里锁的是phone对象。
在标准情况下，两个线程交替执行，先输出发短信，然后输出打电话。
如果senMesg()方法延迟了4秒，那么先输出发短信，再输出打电话。

public class Test1 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.senMesg();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone.call();},"B").start();}
}
class Phone{public synchronized void senMesg(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("发短信");}public synchronized void call(){System.out.println("打电话");}
}

这两个问题涉及同一个对象的同步方法之间的互相调用。当线程执行一个对象的同步方法时，它就持有了这个对象的锁。当它需要再次调用这个对象的另一个同步方法时，如果这个方法也是同步的，那么这个线程就可以直接进入该方法，而无需重新获取锁。这就是“可重入锁”的体现。
在这里插入图片描述

问题三：

添加了一个普通方法hello()，与同步方法senMesg()同时执行。
hello()方法不受锁的影响，所以先输出hello，然后输出发短信。

public class Test2 {public static void main(String[] args) {Phone1 phone = new Phone1();new Thread(()->{phone.senMesg();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone.hello();},"B").start();}
}
class Phone1{public synchronized void senMesg(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("发短信");}public synchronized void call(){System.out.println("打电话");}public void hello(){System.out.println("hello");}
}

这个问题涉及父子类继承关系中使用同步方法。父类中的同步方法在被子类继承后，子类同样可以使用这个同步方法，并且可以在这个同步方法中调用父类的同步方法，这也是“可重入锁”的体现。

问题四：

使用两个不同的Phone对象phone1和phone2，分别执行senMesg()和call()方法。
两个对象的锁是不同的，所以先输出发短信，然后输出打电话。

public class Test3 {public static void main(String[] args) {Phone2 phone1 = new Phone2();Phone2 phone2 = new Phone2();new Thread(()->{phone1.senMesg();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone2.call();},"B").start();}
}
class Phone2{public synchronized void senMesg(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("发短信");}public synchronized void call(){System.out.println("打电话");}
}

这个问题涉及不同对象的同步方法之间的互相调用。当线程执行一个对象的同步方法时，它就持有了这个对象的锁。如果它需要调用另一个对象的同步方法，那么这个线程就需要获取另一个对象的锁才能进入该方法，因此这两个同步方法之间没有“可重入锁”的关系。
在这里插入图片描述

问题五和问题六：

两个静态同步方法，只有一个Phone对象phone1。
根据synchronized关键字的特性，锁的是类模板，即Phone类。
所以无论是调用senMesg()还是call()方法，都会先输出发短信，然后输出打电话。

public class Test4 {public static void main(String[] args) {Phone3 phone1 = new Phone3();new Thread(()->{phone1.senMesg();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone1.call();},"B").start();}
}
class Phone3{public static synchronized void senMesg(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("发短信");}public static synchronized void call(){System.out.println("打电话");}
}

这两个问题涉及静态同步方法和非静态同步方法之间的互相调用。静态同步方法持有的是类锁，而非静态同步方法持有的是对象锁，因此它们持有的锁是不同的，没有“可重入锁”的关系。
在这里插入图片描述

问题七和问题八：

一个静态同步方法senMesg()和一个普通同步方法call()，执行顺序为先打电话再发短信。
两个Phone对象phone1和phone2，分别执行静态同步方法和普通同步方法。
静态同步方法锁的是类模板，普通同步方法锁的是调用者对象。
所以无论是phone1还是phone2，都会先输出打电话，然后输出发短信。

public class Test5 {public static void main(String[] args) {Phone4 phone1 = new Phone4();Phone4 phone2 = new Phone4();new Thread(()->{phone1.senMesg();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone2.call();},"B").start();}
}
class Phone4{public static synchronized void senMesg(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("发短信");}public synchronized void call(){System.out.println("打电话");}
}

总结

当synchronized关键字用于方法或代码块时，它可以用来实现对象级别的锁和类级别的锁。

对象级别锁：
- 当synchronized用于非静态方法时，锁对象是调用该方法的实例对象。即每个对象实例都有自己的锁。
- 当synchronized用于代码块时，锁对象可以是任意的Java对象。通常情况下，我们使用某个共享资源作为锁对象。
- 无论是方法级别的锁还是代码块级别的锁，同一时间只能有一个线程获得锁并执行同步代码，其他线程需要等待锁释放。
类级别锁：
- 当synchronized用于静态方法时，锁对象是当前方法所属的类对象（Class对象）。
- 类级别锁是针对整个类的所有对象实例生效的，不同实例之间共享这个锁。
- 同一时间只能有一个线程获得类级别锁并执行同步代码，其他线程需要等待锁释放。