JUC详解3——8锁问题

最新推荐文章于 2024-09-08 10:40:56 发布
最新推荐文章于 2024-09-08 10:40:56 发布
阅读量320 收藏 1
点赞数
分类专栏： 技术 学习 文章标签： 多线程 java thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41510551/article/details/109254112
版权
本文通过实例代码详细分析了Java中线程同步的锁问题，包括标准情况下的线程执行顺序、添加普通方法的影响、不同对象调用同步方法的情况以及静态同步方法的执行顺序。总结了synchronized锁的对象是方法调用者，锁的作用域以及在多线程环境中的执行逻辑。
摘要由CSDN通过智能技术生成

JUC详解3

8锁问题

1、标准情况，两个线程是先发消息还是，先打电话？ 先发消息再打电话

import java.util.concurrent.TimeUnit;

/**
 * @Description 8锁现象
 * 1、标准情况，两个线程是先发消息还是，先打电话？ 先发消息再打电话
 * 2、让发消息睡4秒，两个线程是先发消息还是，先打电话？ 还是先发消息再打电话；为什么？
 * @Author cai feifei
 */
public class Lock8 {
    public static void main(String[] args) {
        Qq qq = new Qq();
        new Thread(()->{
            qq.sendMessage();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            qq.callQq();
        },"B").start();
    }
}
class Qq{
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    public synchronized void callQq(){
        System.out.println("使用qq打电话");
    }
}
  • 因为锁的存在
  • synchronized锁的对象是方法的调用者，两个方法用的同一把锁；谁先拿到锁，谁就先执行

3、添加一个普通方法，两个线程是先发消息，还是先发hello？

import java.util.concurrent.TimeUnit;

/**
 * @Description
 * 3、添加一个普通方法，两个线程是先发消息，还是先发hello？ 先发消息再发hello？真实：发hello在发消息
 * @Author cai feifei
 */
public class Lock2 {
    public static void main(String[] args) {
        Qq2 qq = new Qq2();
        new Thread(()->{
            qq.sendMessage();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            qq.sayHello();
        },"B").start();
    }
}
class Qq2{
    /**
     * synchronized锁的对象是方法的调用者，两个方法用的同一把锁；谁先拿到锁，谁就先执行
     */
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    public synchronized void callQq(){
        System.out.println("使用qq打电话");
    }

    /**
     * 普通方法，没有锁，不受锁的影响
     */
    public void sayHello(){
        System.out.println("Hello!");
    }
}

4、两个qq（对象），两个同步方法，两个线程是先发消息还是，先打电话？

package com.fly.juc.lock;

import java.util.concurrent.TimeUnit;

/**
 * @Description
 * 4、两个qq（对象），两个同步方法，两个线程是先发消息还是，先打电话？先打电话，在发短信
 * @Author cai feifei
 */
public class Lock2 {
    public static void main(String[] args) {
        Qq2 qq2 = new Qq2();
        Qq4 qq4 = new Qq4();
        new Thread(()->{
            qq2.sendMessage();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            qq4.callQq();
        },"B").start();
    }
}
class Qq2{
    /**
     * synchronized锁的对象是方法的调用者，两个方法用的同一把锁；谁先拿到锁，谁就先执行
     */
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    public synchronized void callQq(){
        System.out.println("使用qq打电话");
    }

    /**
     * 普通方法，没有锁，不受锁的影响
     */
    public void sayHello(){
        System.out.println("Hello!");
    }
}
class Qq4{
    /**
     * synchronized锁的对象是方法的调用者，两个方法用的同一把锁；谁先拿到锁，谁就先执行
     */
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    public synchronized void callQq(){
        System.out.println("使用qq打电话");
    }

    /**
     * 普通方法，没有锁，不受锁的影响
     */
    public void sayHello(){
        System.out.println("Hello!");
    }
}

5、增加2个静态同步方法,一个对象，两个线程是先发消息还是，先打电话？

package com.fly.juc.lock;

import java.util.concurrent.TimeUnit;

/**
 * @Description
 * 5、增加2个静态同步方法,一个对象，两个线程是先发消息还是，先打电话？ 先发消息再打电话；两个对象呢？先发消息再打电话；
 * 6、增加2个静态同步方法,两个对象，两个线程是先发消息还是，先打电话？ 先发消息再打电话；两个对象呢？先发消息再打电话；
 * @Author cai feifei
 */
public class Lock3 {
    public static void main(String[] args) {
        Qq3 qq3 = new Qq3();
        Qq3 qq4 = new Qq3();
        new Thread(()->{
           qq3.sendMessage();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
           qq4.callQq();
        },"B").start();
    }
}
class Qq3{
    /**
     * synchronized锁的对象是方法的调用者
     * static类一加载就执行，所以此时锁的的Qq3的class；一个类的class全局也是唯一的
     */
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    //静态同步方法
    public static synchronized void callQq(){
        System.out.println("使用qq打电话");
    }
}

7如果此时再增加一个普通的synchronized方法，是哪个先执行？

import java.util.concurrent.TimeUnit;

/**
 * @Description
 * 7、在5的基础上增加一个普通同步方法，两个对象，两个线程是先发消息还是，先发hello？先发hello
 * 8、两个对象，一个静态同步方法，一个普通同步方法，两个线程是先发消息还是，先发hello？先发hello
 * @Author cai feifei
 */
public class lock4 {
    public static void main(String[] args) {
    Qq6 qq6 = new Qq6();
    Qq6 qq61 = new Qq6();
    new Thread(()->{
        qq6.sendMessage();
    },"A").start();
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    new Thread(()->{
        qq61.sayHello();
    },"B").start();
}
}
class Qq6{
    //静态同步方法锁的是类
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("使用qq发消息");
    }
    //静态同步方法
    public static synchronized void callQq(){
        System.out.println("使用qq打电话");
    }
    //普通同步方法锁的是对象
    public synchronized void sayHello(){
        System.out.println("Hello!");
    }
}

总结：

new this 锁的是具体对象
static Class锁的是整个类的模板
在我们编写多线程程序得时候，只需要搞明白这个到底锁的是什么就不会出错了！

上一篇：JUC详解2——生产者消费者

下一篇：JUC详解4——集合相关

笨菜先飞
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程（24）—— JUC并发编程类库详解
shangjg3的博客
09-03 190
CyclicBarrier 是一个同步辅助类，用于让一组线程到达一个屏障（barrier）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这意味着在修改操作发生时，会创建一个新的数组，并将现有的所有元素复制到新数组中，然后在新数组上进行修改。这意味着在修改操作发生时，会创建一个新的数组，然后将现有的所有元素复制到新数组中，并在新数组上进行修改。当一个线程到达交换点时，它会调用 exchange() 方法，该方法会尝试将该线程的数据与另一个线程的数据交换。
JUC详解6——读写锁
qq_41510551的博客
10-24 354
JUC详解6ReadWriteLock（读写锁）阻塞队列：BlockingQueue四组apiSynchronousQueue ReadWriteLock（读写锁） 多读一写 /** * 读-读：可共存；读锁：共享锁：一次可以被多个线程占有 * 读-写：不可共存 * 写-写：不可共存；写锁：独占锁：一次只能被一个线程占有 */ public class ReadWriteLockTest { public static void main(String[] args) {
JUC详解2——生产者消费者
qq_41510551的博客
10-24 330
JUC详解2生产者消费者使用synchronized方法解决使用lock解决生产者消费者问题高频面试题：一个主线程三个子线程，如何让三个子线程执行结束再执行主线程 生产者消费者 线程间的通信问题——生产者消费者问题 一个简单的生产者消费者模型（使用synchronized） 使用synchronized方法解决 package com.fly.juc.pc; /** * @Description 生产者、消费者 * 线程间通信问题————生产者、消费者问题：等待唤醒；通知唤醒 * 线程交替执行：P：
JUC详解（各种乱七八糟的锁）
qdyones的博客
02-19 2533
JUC 进程和线程： 进程：一个进程可以包含多个线程，至少是一个线程，java默认2个线程——main、GC（垃圾回收） 线程：开了一个软件，写字的时候也会有自动保存的线程在进行，Thread、Runnable、Callable java开启不了线程，java操作的是底层的C++，java无法操作，用的是虚拟机 并发与并行： 并发：多线程操作同一个资源（假设cpu只有一核的时候，模拟多线程，快速交替处理线程） 并行：CPU多核情况下才有，多个线程同时执行 并发编程的本质：充分利用电脑的CPU 线程有几种
JUC 常见的锁
Java和算法学习的博客
09-11 1981
目录一、AtomicInteger1、底层实现（1） 如果在执行CAS操作的时候，在判断值是否为我期望的值后，马上有其他线程把这个值改为了其他的值，那这种情况不是依然有问题吗？（2）ABA问题（3）CAS底层是怎么做到的？2、SyncLong VS AtomicLong VS LongAdder二、ReentrantLock1、公平锁与非公平锁2、reentrantlock VS synchronized三、CountDownLatch（倒数 门闩）四、CyclicBarrier （循环 栅栏）五、Phas
JUC基石——Unsafe类
12-21
《JUC基石——Unsafe类详解》 在Java并发编程领域，`Unsafe`类扮演着一个特殊的角色，尽管它被标记为“不安全”，但却是Java并发库（JUC）中的重要基石，尤其在高并发场景下，如`ConcurrentHashMap`、`Atomic`系列...
JUC详解 | JUC概述
蕤荥的成长博客
11-01 4979
JUC就是在 Java 5.0 提供了 `java.util.concurrent`(简称JUC)包，在此包中增加了在并发编程中很常用的工具类。此包包括了几个小的、已标准化的可扩展框架，并提供一些功能实用的类，没有这些类，一些功能会很难实现或实现起来冗长乏味。
高并发JUC详解
weixin_48958124的博客
08-26 2080
多线程进阶之高并发编程
Springboot 进行分页操作（通过原生sql语句进行）
qq_41510551的博客
07-31 2099
为什么进行分页操作 因为列表内容太多了，所以使用分页进行显示。 分页的核心就是计算每页多少记录和总页数以及第几页。 操作 mysql的分页语句： select * from student limit 页数*页面大小,页面大小 1、首先先写如何计算每页多少记录和第几页， 每页展示数据需要先进行设置：pageSize=4; 获取总条数：sql语句在持久层（Dao）编写获取总条数方法 public int getCount() { //获取总的条数 String
MySQL将查询到的多条语句插入表中
qq_41510551的博客
08-29 1730
MySQL将查询到的多条语句插入表中 插入单行数据时： #insert into 表名 (字段名1 ,字段名2,....,字段名) values(值1,值2,....,值); insert into myschool.`result` (studentNo ,subjectNo ,examDate ,studentResult ) values(1,2,2020-09-08 00:00:00.0,56 ); 当插入多条数据 #insert into 表名 (字段名1 ,字段名2,....,字段名
Swagger2的配置及使用
qq_41510551的博客
10-08 957
Swagger2的配置及使用 官网文档：https://swagger.io/docs/ Swagger是什么 1、是一款让你更好的书写API文档的规范且完整框架。 2、提供描述、生产、消费和可视化RESTful Web Service。 3、是由庞大工具集合支撑的形式化规范。这个集合涵盖了从终端用户接口、底层代码库到商业API管理的方方面面。 swagger的基础注解介绍 swagger通过注解生成接口文档，包括接口名、请求方法、参数、返回信息的等等。 @Api：修饰整个类，描述Controller的作
redis学习笔记
qq_41510551的博客
11-30 646
redis学习笔记redis学习笔记安装基础知识redis的数据类型redis的五大数据类型常见数据类型操作命令redis的配置文件持久化RDB（Redis DataBase）AOF（Append only File）AOF启动/修复/恢复Rewrite redis学习笔记 安装 下载 方式一 1. 获取安装源 wget http://download.redis.io/releases/redis-5.0.3.tar.gz 2. 解压 tar zxvf redis-4.0.8.tar.gz 方
JUC详解5
qq_41510551的博客
10-24 375
JUC详解5Callable常用的辅助类CountDownLatch（减法计数器）CyclicBarrier（加法计数器）Semaphore（信号量） Callable 可以有返回值 可以抛出异常 方法不同：run/call 怎么让Callable能够启动线程呢？ 测试 import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Fu
JUC详解7——线程池
qq_41510551的博客
10-24 312
JUC详解7——线程池线程池三大方法七大参数四种拒绝策略最大线程该如何定义 线程池 线程池：三大方法，七大参数，四种拒绝策略 池化技术 程序运行的本质：占用系统资源！优化资源的使用===>池化技术 线程池、连接池、对象池、内存池。。。。。创建、销毁十分浪费资源 池化技术：先创建好一些资源，有人要用，就来我这里拿。用完之后还给我 线程池的好处： 降低资源消耗 提高响应速度 方便管理 线程复用、控制最大并发数、管理线程 三大方法 import java.util.concurrent.Execut
JUC详解8
qq_41510551的博客
10-24 233
JUC详解8四大函数式接口functionPredicateConsumersupplierStream流式计算ForkJoin异步回调 四大函数式接口 lambda表达式、链式编程、函数式接口、Stream流式计算 函数式接口：只有一个方法的接口: @FunctionalInterface public interface Runnable { public abstract void run(); } //可以简化编程，在新版框架含有大量应用函数式接口 function public
JUC详解4——集合相关
qq_41510551的博客
10-24 188
JUC详解4集合CopyOnWriteArrayListList不安全set不安全Map不安全 集合 CopyOnWriteArrayList 集合类不安全 List不安全 先看一段代码： public class ListTest { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); for (int i=0;i<=1
Lambda表达式
qq_41510551的博客
08-26 129
Lambda表达式 语法 //() -> {} (String first, String second)->{first.length()-second.length()}; 注： ()：参数；->：指向； {}：代码体 函数式接口 对于只有一个抽象方法的接口，就可以提供一个lambda表达式。这种接口称为函数式接口 @FunctionalInterface //一个接口只能有一个lambda的函数接口 public interface lambdaInter { void
spring事务详细讲解-深入浅出
最新发布
小电玩
09-08 433
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
JUC自旋锁详解与Java并发公开课实践
在JUC并发编程的公开课第二讲中，主要讨论了第一章——Java锁，特别是自旋锁的概念和应用。 1. 自旋锁（Spin Lock）：自旋锁是一种特殊的锁机制，当一个线程尝试获取锁时，它不会立即阻塞自己，而是不断地尝试获取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值