JUC并发编程学习笔记（四）8锁现象

高同学，你好2023-11-02 21:59

8锁现象

八锁->就是关于锁的八个问题

锁是什么，如何判断锁的是谁

对象、class模板

深刻理解锁

锁的东西无外乎就两样：1、同步方法的调用者，2、Class模板。

同一个锁中，只有当前线程资源释放后才会被下一个线程所接手。

同步方法的调用者是两个不同的实例时，互不相关。

静态同步方法(static)锁的是整个Class模板，和同步方法的调用者也不是同一个锁；切Class模板在Java程序中唯一。

代码示例

1、浅浅理解锁的作用

同一把锁中根据执行先后释放资源，保证一个资源的使用顺序

java 复制代码 
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、区分锁的对象

不同的实例使用的锁并非同一把，所以也无法同时锁定某个固定的资源、无法对同一资源进行有顺序的操作

java 复制代码 
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执行顺序执行

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模板，并且在反射时就已经被创建了

java 复制代码 
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的执行顺序来，并不存在锁定资源的情况

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("打电话");
    }
}
相关推荐
sun03223 小时前
【架构基础】Spring中的PropertySourcesPlaceholderConfigurer介绍 （并非新知识，比较古老的一种使用方式）
java·spring·架构
chilavert3184 小时前
技术演进中的开发沉思-356：重排序（中）
java·开发语言
毕设源码-邱学长4 小时前
【开题答辩全过程】以 基于SSM的儿童福利院管理系统为例，包含答辩的问题和答案
java·eclipse
TT哇4 小时前
【实习】数字营销系统 银行经理端（interact_bank）前端 Vue 移动端页面的 UI 重构与优化
java·前端·vue.js·ui
Elieal4 小时前
SpringBoot 数据层开发与企业信息管理系统实战
java·spring boot·后端
识君啊4 小时前
MyBatis-Plus 逻辑删除导致唯一索引冲突的解决方案
java·spring boot·mybatis·mybatis-plus·唯一索引·逻辑删除
Coder_Boy_4 小时前
Java开发者破局指南：跳出内卷，借AI赋能，搭建系统化知识体系
java·开发语言·人工智能·spring boot·后端·spring
QT.qtqtqtqtqt4 小时前
SQL注入漏洞
java·服务器·sql·安全
独自破碎E4 小时前
BISHI23 小红书推荐系统
java·后端·struts
xqqxqxxq4 小时前
Java IO 核心：BufferedReader/BufferedWriter & PrintStream/PrintWriter 技术笔记
java·笔记·php
热门推荐
01GitHub 镜像站点02Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services03openclaw配置教程（linux+局域网ollama）04UV安装并设置国内源05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南06Linux下V2Ray安装配置指南07OpenClaw Chrome扩展使用教程 - 浏览器中继控制08Claude Code Skills 实用使用手册09openclaw使用nginx反代部署过程 与disconnected (1008): pairing required解决10Vue-skills的中文文档