8锁现象详解

如何判断锁的是谁！理解锁！锁到底锁的是谁！

对象、class   。

1.前两个问题

package com.kuang.lock8;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 8锁 ，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印  发短信还是打电话？ 1/发短信 2/打电话
 * 2、sendSms 延迟4秒，两个线程先打印  发短信还是 打电话 ？ 1/发短信 2/打电话
 */
public class Test1 {
 
    public static void main(String[] args) {
        Phone phone = new Phone();
     //锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！
        new Thread(()->{
            phone.sendSms();
        },"A").start();
 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        new Thread(()->{
            phone.call();
        },"B").start();
 
    }
 
 
 
}
class Phone{
    //synchronized 锁的对象是方法的调用者！  phone
    //两个方法用的是同一个锁，谁先拿到谁执行!
    public synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public synchronized void call(){
        System.out.println("call");
    }
 
 
 
 
 
}

2.3-4问题

package com.kuang.lock8;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 8锁 ，就是关于锁的8个问题
 *
 * 3.增加了一个普通方法！ 发短信还是Hello？   是hello.
 * 4. 两个对象，两个同步方法！ 发短信还是打电话？   是打电话
 */
public class Test2 {
 
    public static void main(String[] args) {
       //两个对象 ，两个调用者 ，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
     //锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        new Thread(()->{
            phone2.hello();
        },"B").start();
 
    }
 
 
 
}
class Phone2{
    //synchronized 锁的对象是方法的调用者！  phone
    //两个方法用的是同一个锁，谁先拿到谁执行!
    public synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public synchronized void call(){
        System.out.println("call");
    }
 
    //这里没有锁！不是同步方法，不受锁的影响!
   public void hello(){
       System.out.println("hello");
   }
 
 
 
}

3.5-6

package com.kuang.lock8;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 8锁 ，就是关于锁的8个问题
 *
 * 5.增加两个静态同步方法,只有一个对象,先打印，发短信？打电话？ 打印发短信！！因为锁的都是同一个class对象
 * 6.增加两个对象,两个静态的同步方法,先打印，发短信？打电话？ 打印发短信！！  因为锁的都是同一个class对象，与对象本身无关
 */
public class Test3 {
 
    public static void main(String[] args) {
       //两个对象的class 类模板只有一个，static，锁的是class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
 
 
     //锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        new Thread(()->{
            phone2.call();
        },"B").start();
 
    }
 
 
 
}
//Phone3唯一的一个Class对象
class Phone3{
    //synchronized 锁的对象是方法的调用者！  phone
    //两个方法用的是同一个锁，谁先拿到谁执行!
    //static  静态方法
    //类一加载就有了！锁的Class 锁的是模板
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    public static synchronized void call(){
        System.out.println("call");
    }
 
 
 
 
 
}

4.第7个问题

package com.kuang.lock8;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 8锁 ，就是关于锁的8个问题
 *
 * 7. 1个静态的同步方法，1个普通的同步方法，1个对象 ，先打印发短信？还是打电话？ 打电话，因为锁的不是同一个东西，而打电话的睡眠时间少，所以打电话先打印
 *
 */
public class Test4 {
 
    public static void main(String[] args) {
       //两个对象的class 类模板只有一个，static，锁的是class
        Phone4 phone = new Phone4();
 
 
 
     //锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！
        new Thread(()->{
            phone.sendSms();
        },"A").start();
 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        new Thread(()->{
            phone.call();
        },"B").start();
 
    }
 
 
 
}
//Phone3唯一的一个Class对象
class Phone4{
  //静态的同步方法
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    //普通的同步方法
    public synchronized void call(){
        System.out.println("call");
    }
 
 
 
 
 
}

5.8-9个问题

package com.kuang.lock8;
 
import java.util.concurrent.TimeUnit;
 
/**
 * 8锁 ，就是关于锁的8个问题
 *
 * 8. 1个静态的同步方法，1个普通的同步方法，2个对象 ，先打印发短信？还是打电话？ 打电话，因为锁的不是同一个东西，而打电话的睡眠时间少，所以打电话先打印
 * 9. 如何让静态方法与 普通方法实现同步，用 synchronized 在普通方法里 锁住 字节码对象，就可以实现同步  然后就是发短信先打印了
 *
 */
public class Test5 {
 
    public static void main(String[] args) {
       //两个对象的class 类模板只有一个，static，锁的是class
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();
 
 
 
     //锁的存在，才导致，它先执行。面试的时候，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
 
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        new Thread(()->{
            phone2.call();
        },"B").start();
 
    }
 
 
 
}
//Phone3唯一的一个Class对象
class Phone5{
  //静态的同步方法
    public static synchronized void  sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }
    //普通的同步方法
    public  void call(){
        synchronized(Phone5.class){
            System.out.println("call");
        }
 
    }
 
 
 
 
 
}

加拓展