8锁现象
八锁->就是关于锁的八个问题
锁是什么，如何判断锁的是谁
对象、class模板
深刻理解锁
锁的东西无外乎就两样：1、同步方法的调用者，2、Class模板。
同一个锁中，只有当前线程资源释放后才会被下一个线程所接手。
同步方法的调用者是两个不同的实例时，互不相关。
静态同步方法(static)锁的是整个Class模板，和同步方法的调用者也不是同一个锁；切Class模板在Java程序中唯一。
代码示例
1、浅浅理解锁的作用
同一把锁中根据执行先后释放资源，保证一个资源的使用顺序
package org.example.phone;import java.util.concurrent.TimeUnit;public class Test1 { public static void main(String[] args) {// 标准情况下，打印顺序为 1、发短信，2、打电话// 给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话// 可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况// phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行// 锁的对象是该方法的调用者，即phone1 Phone1 phone1 = new Phone1(); new Thread(()->{ phone1.sendMsg(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ phone1.call(); },"B").start(); }}class Phone1{// synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象 public synchronized void sendMsg(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("发短信"); } public synchronized void call(){ System.out.println("打电话"); }}
2、区分锁的对象
不同的实例使用的锁并非同一把，所以也无法同时锁定某个固定的资源、无法对同一资源进行有顺序的操作
package org.example.phone;import java.util.concurrent.TimeUnit;public class Test3 { public static void main(String[] args) {// 标准情况下，打印顺序为 1、发短信，2、打电话// 给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话// 可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况// phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行// 锁的对象是该方法的调用者，即phone1// 调用两个不同对象的方法，锁的是两个不同的对象，此时先出现打电话，说明不同对象之间的锁互不影响 Phone3 phone3_1 = new Phone3(); Phone3 phone3_2 = new Phone3(); new Thread(()->{ phone3_1.sendMsg(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ phone3_2.call(); },"B").start(); }}class Phone3{ // synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象 public synchronized void sendMsg(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("发短信"); } public synchronized void call(){ System.out.println("打电话"); } // 当在资源类中添加了一个普通方法后，先输出hello// 没有锁，不是同步方法，不受锁的影响 public void hello(){ System.out.println("Hello"); }}
3、了解锁的参与者
只有同步方法参与锁，普通方法依旧按照java执行顺序执行
package org.example.phone;import java.util.concurrent.TimeUnit;public class Test2 { public static void main(String[] args) {// 标准情况下，打印顺序为 1、发短信，2、打电话// 给sendMsg内部延迟四秒执行，执行顺序依旧是 1、发短信，2、打电话// 可知，并非是我们所想的，A线程在前面就先执行，而是锁的机制导致了这种情况// phone1只创建了一个对象，所以这个对象的锁只有一把，谁先拿到就是谁先执行// 锁的对象是该方法的调用者，即phone1 Phone2 phone2 = new Phone2(); new Thread(()->{ phone2.sendMsg(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ phone2.hello(); },"B").start(); }}class Phone2{ // synchronized锁的对象是方法的调用者，Phone1只new了一个对象，所以锁的是new出来的整个对象 public synchronized void sendMsg(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("发短信"); } public synchronized void call(){ System.out.println("打电话"); }// 当在资源类中添加了一个普通方法后，先输出hello// 没有锁，不是同步方法，不受锁的影响 public void hello(){ System.out.println("Hello"); }}
4、明白锁能锁谁
锁只能锁两个东西，一个是同步方法的调用者，一个是整个Class模板（全局唯一），一旦使用static创建静态同步方法，那么该方法的锁锁的就是全局唯一的Class模板，并且在反射时就已经被创建了
package org.example.phone;import java.util.concurrent.TimeUnit;public class Test4 { public static void main(String[] args) {// 两个对象的Class类模板只有一个;static，锁的是Class Phone4 phone4_1 = new Phone4(); Phone4 phone4_2 = new Phone4(); new Thread(()->{ phone4_1.sendMsg(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ phone4_2.call(); },"B").start(); }}class Phone4{// synchronized锁的对象是方法的调用者// 注:增加了static静态方法 此时调用该方法的就变成了Phone4的反射对象，全局唯一// 此时锁的就是Class模板了，即不管你有几个调用者，都在同一个锁// static方法类一加载就有了！锁的是Class public static synchronized void sendMsg(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("发短信"); } public static synchronized void call(){ System.out.println("打电话"); }}
5、深入理解锁的是谁
静态同步方法和普通同步方法在一起使用时，锁的并非同一对象，所以打印顺序也时按java的执行顺序来，并不存在锁定资源的情况
package org.example.phone;import java.util.concurrent.TimeUnit;/** 1、一个静态同步方法，一个普通同步方法，先打印发短信还是打电话* 两个方法一个锁的是Class模板，一个锁的是调用者，锁的不是同一对象，所以延迟四秒的静态同步方法后打印，延迟一秒的普通同步方法先打印** */public class Test5 { public static void main(String[] args) { Phone5 phone5_1 = new Phone5();// Phone5 phone5_2 = new Phone5(); new Thread(()->{ phone5_1.sendMsg(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ phone5_1.call(); },"B").start(); }}class Phone5{// 锁的是Class模板 public static synchronized void sendMsg(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println("发短信"); }// 锁的是调用者 public synchronized void call(){ System.out.println("打电话"); }}
经验首页