JUC编程—8锁问题

最新推荐文章于 2024-01-16 11:17:57 发布

原创最新推荐文章于 2024-01-16 11:17:57 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

JUC学习专栏收录该内容

16 篇文章

订阅专栏

本文通过一系列示例探讨了Java中锁的使用，包括对象锁、类锁以及静态同步方法。分析了不同锁的实现方式对并发执行的影响，强调了锁的对象、同步方法的调用者以及静态方法锁定Class模板的特性。总结了静态同步方法与普通同步方法的执行顺序取决于锁的不同和代码执行的时间顺序。

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