JUC编程—8锁问题

8锁问题

如何判断锁的是谁！什么是锁，锁的到底是谁

锁只会锁两个东西：对象、Class

package com.zkw.JUC并发编程.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印 发短信 还是 打电话？ 先 发短信 在 打电话
 * 2、sendSms 延时4秒钟，两个线程先打印 发短信 还是 打电话？ 先 发短信 在 打电话
 * 解释：synchronized 锁的对象是方法的调用者；两个方法用的是同一个锁，谁先拿到就先执行谁
 * main方法里边程序是自上而下执行的
 */
public class Test01 {
    public static void main(String[] args)  {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        //让其睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"A").start();

    }
}
class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信！！！");
    }
    public synchronized void call(){
        System.out.println("打电话！！！");
    }
}

package com.zkw.JUC并发编程.Lock8;

import java.awt.*;
import java.util.concurrent.TimeUnit;

/**
 * 3、增加一个普通方法后！先执行 发短信 还是 hello？ 先 hello 在 发短信
 * 解释：因为普通方法不受锁的限制，所以就按照消耗时间的多少先后执行
 * 4、两个对象，两个同步方法，发短信 还是 打电话？ 先 打电话 在 发短信
 * 解释：因为两把锁，那就是按照时间的大小来执行的
 */
public class Test02 {
    public static void main(String[] args)  {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //让其睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

       /* new Thread(()->{
            phone1.hello();
        },"B").start();*/

        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！！！");
    }

}

package com.zkw.JUC并发编程.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 5、增加两个静态的同步方法，只有一个对象 ，先打印 发短信 还是 打电话？ 先 发短信 在打电话
 * 解释：Phone3 唯一的一个Class 对象；static 是静态方法；类一加载就有了，锁的就是Class模板
 *6、两个对象！增加两个静态的同步方法，先打印 发短信？打电话？ 先 发短信 在 打电话
 * 解释：两个对象的Class类锁只有一个，static 锁的就是Class模板
 */

public class Test03 {
    public static void main(String[] args)  {
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //让其睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

       /* new Thread(()->{
            phone1.call();
        },"B").start();*/

        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("打电话！！！");
    }
}

package com.zkw.JUC并发编程.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7、一个静态同步方法，1个普通同步方法，一个对象，先打印 发短信？打电话？ 先 打电话 在 发短信
 * 8、一个静态同步方法，1个普通同步方法，、两个对象，先打印 发短信？打电话？ 先 打电话 在 发短信
 ** 解释：static 是静态方法 锁的是Class模板；普通方法 锁的是调用者 锁的对象不一样，就按照消耗时间的大小先后执行
 */
public class Test04 {
    public static void main(String[] args)  {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //让其睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

      /*  new Thread(()->{
            phone1.call();
        },"B").start();*/

        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}

//Phone4 唯一的一个Class 对象
class Phone4{

    //static 是静态方法 锁的是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("打电话！！！");
    }
}

总结：

1、同步静态方法锁的是Clas，故不受创建对象的数量影响。

2、普方法不受锁的影响。