JUC-八锁问题学习

最新推荐文章于 2024-04-20 01:32:17 发布
最新推荐文章于 2024-04-20 01:32:17 发布
阅读量125 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43615903/article/details/106010826
版权

demo1

/**
 * 先输出palyGame还是listenMusic?
 * 答案:listenMusic
 * 分析:先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个同步方法，
 * 于是其他与对象有关的同步方法等待，于是him.palyGame()等待。
 * him.listenMusic()执行完毕后，释放锁，也就是释放该该对象，此时him.palyGame()可以获得该对象执行
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        He him = new He();
        new Thread(() -> {
            him.listenMusic();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            him.palyGame();
        }).start();
    }
}

class He {
    public synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public synchronized void listenMusic() {
        System.out.println("listenMusic");
    }
}

demo2

package com.company.lock8;

import java.util.concurrent.TimeUnit;


/**
 * 先输出palyGame还是listenMusic?
 * 答案:listenMusic
 * 分析:先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个同步方法，
 * 于是该方法的实例对象加锁，其他与该实例对象有关的同步方法因拿不到锁而等待。
 * listenMusic()方法内部会睡上5秒，于是５秒后输出listenMusic，执行完毕，释放锁,其他同步方法可以获得该对象,
 * 此时，同步方法palyGame可以被调用执行。
 */
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        He2 him = new He2();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            him.palyGame();
        }).start();

    }
}

class He2 {
    public synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo3

 /**
 * 先输出palyGame还是listenMusic?
 * 答案:palyGame
 * 分析:先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个同步方法，
 * 于是其他与对象有关的同步方法等待，但是，此案例中palyGame()是一个普通方法，它不会等待。
 * 所以线程一里面的him.listenMusic()和线程二中的him.palyGame()并行执行,但由于
  * lilistenMusic()方法内部会睡上5秒，于是先输出playgame,５秒后才输出listenMusic.
 */
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        He3 him = new He3();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            him.palyGame();
        }).start();

    }
}

class He3 {
    //普通方法
    public  void palyGame() {
        System.out.println("palyGame");
    }

    public synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo4

/**
 * 先输出palyGame还是listenMusic?
 * 答案:palyGame
 * 分析:先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个同步方法，
 * 于是其他与该象有关的同步方法等待，但是，此时两个方法的调用者是两个不同的对象，所以him.palyGame()不会等待。
 * 由于lilistenMusic()方法内部会睡上5秒，于是先输出playgame,后输出listenMusic.
 */
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        He4 him = new He4();
        He4 him_2 = new He4();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            him_2.palyGame();
        }).start();

    }
}

class He4 {
    public synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo5

/**
 * 先输出palyGame还是listenMusic?
 * 答案:listenMusic
 * 分析: static synchronized 会锁住类的Class对象，先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个静态同步方法，
 * 于是其他与该类有关的静态同步方法等待.listenMusic()方法内部会睡上5秒，于是5s后输出listenMusic.
 * 当静态同步方法listenMusic()执行完毕后，释放锁。其他与该类有关的静态同步方法可以执行。于是palyGame()被调用执行。
 */
public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        He5 him = new He5();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
          him.palyGame();
        }).start();

    }
}

class He5 {
    public static synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public  static synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo6

/**
 * 先输出palyGame还是listenMusic?
 * 答案:listenMusic
 * 分析: static synchronized 会锁住类的Class对象本身，synchronized锁住的是实例对象。两个不是一个锁。
 * 先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个静态同步方法，
 * 于是其他与该类有关的静态同步方法等待.但palyGame()是一个普通的同步方法,两个不是一个锁，不会等待，同时执行。
 * 由于listenMusic()方法内部会睡上5秒，于先输出输出palyGame，后输出listenMusic.
 */
public class Test6 {
    public static void main(String[] args) throws InterruptedException {
        He6 him = new He6();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
          him.palyGame();
        }).start();

    }
}

class He6 {
    public  synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public  static synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo7

/**
 * 先输出palyGame还是listenMusic?
 * 答案:listenMusic
 * 分析: 还是一样，static synchronized 会锁住类的Class对象本身，两个对象是一个锁。
 * 先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个静态同步方法，
 * 于是其他与该类有关的静态同步方法等待.
 */
public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        He7 him = new He7();
        He7  him_2 = new He7();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
          him_2.palyGame();
        }).start();

    }
}

class He7 {
    public  static synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public  static synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

demo8

/**
 * 先输出palyGame还是listenMusic?
 * 答案:palyGame
 * 分析: 还是一样，static synchronized 会锁住类的Class对象本身，synchronized 所得是实例对象；
 * 一个是类模板，一个是对象，两个就不是一把锁。
 * 先走him.listenMusic()所在线程，调用him.listenMusic()，发现该方法是一个静态同步方法，
 * 于是其他与该类有关的静态同步方法等待,但palyGame()是实例对象调用的，更何况还不是且不是静态同步方法，
 * 所以同步执行。一个睡五秒，一个不睡觉。答案palyGame显而易见.
 */
public class Test8 {
    public static void main(String[] args) throws InterruptedException {
        He8  him = new He8();
        He8  him_2 = new He8();
        new Thread(() -> {
            try {
                him.listenMusic();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        ).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
          him_2.palyGame();
        }).start();

    }
}

class He8 {
    public   synchronized void palyGame() {
        System.out.println("palyGame");
    }

    public  static synchronized void listenMusic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        System.out.println("listenMusic");
    }
}

总结与注意

  • static synchronized锁的是类对象本身，是模板。而synchronizeds锁的是实例对象。
  • 当一个线程的同步方法或同步代码块（不管是静态同步方法还是普通同步方法）执行时，它总先要获得锁，才能执行，如果公共资源，也就是这个锁还被其他同步方法或同步代码块霸占着，没有释放，那么这个同步方法必须等待这个锁被释放才能执行。
人语西风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC学习 - 锁升级
TyuIn的博客
12-07 640
一、synchronized 的简单回顾 synchronized 锁有四种状态，无锁、偏向锁、轻量级锁、重量级锁。这几个状态会随着竞争状态逐渐升级，锁可以升级但不能降级，但是偏向锁状态可以被重置为无锁状态。 二、锁升级 1、偏向锁 经过 HotSpot 的作者大量的研究发现大多数时候是不存在锁竞争的，经常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。核心思想： 如果一个线程获得了锁，那么锁就进入偏向模式，此时 Mark Word
个人学习-JUC-笔记
02-25
通过尚硅谷周阳老师的JUC课程，我们可以系统地学习这些知识点，并通过实践提升自己的并发编程能力，为解决复杂的并发问题打下坚实基础。在实际开发中，合理利用JUC工具可以显著提高程序的并发性能和可维护性。
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1400
JUC 八锁现象 Java并发编程
【并发编程】（学习笔记-共享模型之JUC-读写锁原理）-part6
2401_84407923的博客
04-20 702
该类自 JDK 8 加入，是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用加解读锁：加解写锁：乐观读支持方法（乐观读），读取完毕后需要做一次戳校验如果校验通过，表示这期间确实没有写操作，数据可以安全使用，如果校验没通过，需要重新获取读锁，保证数据安全。// 验戳if(!// 锁升级面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。
JUC-公平锁和非公平锁
江黎
09-26 183
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 ..
面试必备系列JUC(6)--八锁详解
欲问君有几多愁的博客
09-06 622
文章目录前言一、锁总述1.1. 乐观锁 VS 悲观锁2.读入数据总结 前言 最近有读者在后台私信，让我讲讲java里常见的锁，第一次被读者提要求，还是很高兴的，查阅了一些资料，尽量将常见的锁的概念讲的清清楚楚，希望读者读后，能对8锁有个清晰的认知！ 今天给大家介绍我一个很有趣的好友，秃头，干瘦，可能喜欢女生的广叔！！ 长相略微显老（认识五年了，颜值一直在40岁上下） 提示：以下是本篇文章正文内容，下面案例可供参考 一、锁总述 广叔：令狐兄，你知道java中常见的锁吗？ 令狐冲：当然知道，话说当年java
tuling-juc-final.zip
05-23
synchronized提供了两种用法：修饰实例方法和修饰代码块，分别作用于对象锁和类锁。在"tuling-juc-final"项目中，我们可能看到如何使用synchronized来实现线程安全的代码示例。 `volatile`关键字则是另一种保证线程...
heima-JUC-资料
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：Java通过...
JUC-master
03-21
《JUC：Java并发编程的艺术》 在Java世界中，JUC（Java Util Concurrency）是并发编程的核心库，它提供了丰富的...通过深入学习JUC-master项目，我们可以更深入地理解Java并发编程的原理和实践，提升我们的编程技能。
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
"Java 多线程与并发(7-26)-JUC - 类汇总和学习指南" Java 多线程与并发是 Java 编程语言中的一部分，用于处理多线程和并发编程。Java 提供了一个名为 JUC（Java Utilities for Concurrency）的框架，用于帮助开发者...
基于卷积神经网络的食物识别及实现.pdf
07-22
在超市无人结算服务中，使用电子标签对部分货物如水果、蔬菜等进行结算的成本过高、便捷性不高，至今依然采用人工结算的方式。 针对这一问题，本文提出了基于卷积神经网络的食物识别方法。 通过自建水果数据集来训练卷积神经网络分类模型；基于训练后的模型构建可视化平台进行食物识别。 实验结果表明，利用卷积神经网络的食物识别的预测准确率 为 ９６．３４％。
使用 Javascript 编写的 ToDo List 应用程序及其源代码.zip
07-22
项目：使用 JavaScript 编写的 ToDo List 应用程序及其源代码 ToDo List App 是一个使用 JavaScript、CSS 和 HTML 开发的简单项目。这个项目很有趣。在这里，用户可以添加待办事项详细信息的数量，您可以看到以列表形式存储的详细信息，如便签。此外，如果用户想删除列表项，也可以删除它。   项目制作 ToDo List App 项目仅包含 HTML、CSS 和 JavaScript。谈到该系统的功能，用户可以列出他们必须完成的日常工作并将其作为记录保存。您只需在文本字段中输入工作信息，然后按 Enter 键即可将信息添加到记录中。该项目包含大量 JavaScript，用于使项目正常运行。 如何运行该项目？ 要运行此项目，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要运行此系统，首先，通过单击 index.html 文件在浏览器中打开项目。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
MobaXterm-Installer-v24.2.zip（windows版本），41M
07-22
MobaXterm_Installer_v24.2解压之后，执行MobaXterm_installer_24.2.msi安装程序，无脑安装即可。 目前个人觉得最好用的一款远程连接工具，支持SSH、Telnet、Rsh、Xdmcp、RDP、VNC、FTP、SFTP、Serial、File、Shell、Browser、Mosh、Aws S3、WSL等多种连接，并且可以提供可视化linux的文件夹系统，可以直接点击查看、创建、删除、修改等可视化操作，十分方便，传输文件直接拖动到对应的文件夹即可快速传输！速度吊打scp命令传输！
毕业设计，基于Python+Django+Vue+MySql开发的前后端分离的足球青训俱乐部系统，内含完整源代码，视频教程
07-22
毕业设计，基于Python+Django+Vue+MySql开发的前后端分离的足球青训俱乐部系统，内含完整源代码，数据库脚本，视频教程 随着社会经济的快速发展，人们对足球俱乐部的需求日益增加，加快了足球健身俱乐部的发展，足球俱乐部管理工作日益繁忙，传统的管理方式已经无法满足足球俱乐部管理需求，因此，为了提高足球俱乐部管理效率，足球俱乐部管理后台系统应运而生。 本文重点阐述了足球青训俱乐部管理后台系统的开发过程，以实际运用为开发背景，基于Django框架，运用了Python技术和MySQL数据库进行开发设计，充分保证系统的安全性和稳定性。本系统界面良好，操作简单方便，通过系统概述、系统分析、系统设计、数据库设计、系统测试这几个部分，详细的说明了系统的开发过程，最后并对整个开发过程进行了总结，实现了俱乐部相关信息管理的重要功能。 本系统经过测试，运行效果稳定，操作方便、快捷，是一个功能全面、实用性好、安全性高，并具有良好的可扩展性、可维护性的足球青训俱乐部管理后台系统。 关键字：俱乐部管理；Django框架；Python技术；MySQL数据库 本基于Web的足球青训俱乐部管理后台
2020年POI数据集.txt
最新发布
07-22
2020年
科技专题研究：MWC：关注5G-A-AIGC-卫星通信.pdf
07-22
科技专题研究：MWC：关注5G-A_AIGC_卫星通信.pdf
人工神经网络基础培训PPT.pdf
07-22
内容提要 • 介绍 – 发展历史 – 网络结构 • 基本模型 – 单层感知器、多层感知器、RBF网络 • 扩展模型 – Hopfield网络、RBM、DNN、CNN等
交巡警服务平台的设置与调度代码部分
07-22
本文深入剖析了交巡警服务平台的构建与调度系统的核心代码实现，不仅展示了复杂系统背后的逻辑之美，还巧妙融合了多位博主的智慧火花。在代码的编织过程中，作者既尊重并借鉴了前人的宝贵经验，确保了技术的先进性与实用性，又通过个人对业务逻辑的深刻理解，亲自撰写了那些关乎系统灵魂的关键部分。AI辅助完成的简短注释，虽非出自人手，却也精准高效，为代码的可读性增色不少。 通过阅读本文，读者不仅能够获得关于Lingo和Matlab这两种强大工具在交通管理领域应用的深刻洞见，还能在潜移默化中提升编程技能与问题解决能力。这不仅是一次技术知识的盛宴，更是一场思维方式的启迪之旅。作者通过分享自己的实践经验与心得，鼓励每一位探索者勇于创新，敢于将理论知识转化为解决实际问题的强大武器。在这场技术与智慧的交融中，每个人的编程之路都将因此而更加宽广与深远。
互联网大厂算法面试常用题目总结整理
07-22
主要是总结近几年，互联网大厂常见算法面试题，个人总结，帮助快速求职面试，里面包括丰富的数据结构和常用的算法，对于要校招或者社招的同学来说，是不可缺少的部分，值得下载
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，集合类的不安全性，Callable的使用以及常用的辅助类。 JUC，即Java Util ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值