八锁问题详解

Posted 2021-06-15 strandtrack

 

就是关于锁的八个问题

package sort;

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 锁的对象是方法的调用者！、 // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

第一个问题的结果和第二个问题的结果都是

发短信
打电话

/*** 3、 增加了一个普通方法后！先执行发短信还是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.call();
        }, "B").start();
    }
}

class Phone2 {
    // synchronized 锁的对象是方法的调用者！
    public synchronized void sendSms() {
        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");
    }
}

第一个问题是先执行普通方法，因为他不是同步方法不受锁的影响，并且发短信睡眠了4秒，所以发短信肯定在她后面。

第二个问题是先打电话，因为是两把锁，互不影响，然后发短信睡4秒

/***5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？*/
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 锁的对象是方法的调用者！ 
    // static 静态方法 // 类一加载就有了！锁的是Class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

第一个和第二个问题都是发短信，因为用的是同一个锁，类锁，谁先抢到谁先执行，所以发短信先抢到。

/**
 * 1、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？ 
 * 2、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
 */
public class Test4 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        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 Phone4 { // 静态的同步方法 锁的是 Class 类模板
    public static synchronized void sendSms() {
        try {

            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 普通的同步方法 锁的调用者
    public synchronized void call() {
        System.out.println("打电话");
    }
}

第一个问题和第二个问题都是先打电话，因为用的都不是一个锁，一个是类锁，一个是锁的调用者。