【Java并发编程] 线程八锁问题

news2024/11/19 22:44:05

文章目录

    • 1.共享会出现什么问题
    • 2. 什么是临界区
    • 3. synchronized解决方案
    • 4 线程八锁

1.共享会出现什么问题

首先，我们先了解对某一资源共享会出现什么问题，然后怎么解决这个问题。

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

public class Main {
    
    public static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    counter++;
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    counter--;
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter);
    }
}

结果分析

我们多次运行上面代码，会发现结果有0，有负数也有正数。这是为什么呢，应该不都是0才对吗，为啥会出现正、负数呢，而且0出现的次数很小，大多都是正、负数。

这是因为 Java 中对静态变量的自增、自减并不是原子操作，要彻底理解，必须从字节码来进行分析。

例如对于i++而言( i 为静态变量)，实际会产生如下的 JVM 字节码指令：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

而对于i--也是类似：

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

而Java的内存模型如下，完成静态变量的自增、自减操作需要在主存和工作内存中进行数据交换：

image-20230112132909452

如果在单线程的情况下上面代码顺序执行是没有问题的：

image-20230112155040603

出现负数的情况：

image-20230112155131970

线程2将i减1在最后一步写入静态变量时，发生线程切换，线程1将i加1写入后，再次切换到线程2，线程2在写入，这样就产生并发带来的线程不安全问题。

出现正数的情况：

image-20230112161820945

2. 什么是临界区

首先，我们要知道一个很虚运行多个线程本身是没有问题的，问题就出现多个线程访问共享资源：

  • 多个线程读共享资源也没有我呢提
  • 但多个线程对共享资源进行读写操作时就会发生指令交错，就会出现问题

一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

例如：

static int counter = 0;
static void increment() 
// 临界区
{ 
 counter++;
}
static void decrement() 
// 临界区
{ 
 counter--;
}

3. synchronized解决方案

synchronized：俗称对象锁，它采用互斥的方式让同一时刻至多只有一个线程能拥有对象锁，其他线程在想获取这个对象锁的线程就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换带来的线程安全问题。

我们先来了解几个问题，不清楚这几个问题在后续的学习过程中会很难进展：

  1. 什么是“锁”？
  2. 锁的的是线程代码还是什么？

我们初学多线程时都可能会被带偏，觉得synchronized就是锁，其实对象才是锁，synchronized其实是给对象加锁，所以我们一直都是在给对象加锁，严格意义上并不是在给某个代码块加锁。

  1. synchronized作用于成员变量和非静态方法时，锁住的是对象的实例，即this对象

  2. synchronized作用于静态方法时，锁住的是Class实例

  3. synchronized作用于一个代码块时，锁住的是所有代码块中配置的对象

synchronized 语法

synchronized(对象) // 线程1， 线程2(blocked)
{
  	临界区
}

线程1、线程2都去给某个对象加锁，但只有一个线程能够加锁成功。

解决上诉问题代码

public class Main {
    public static final Object room = new Object();
    public static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    synchronized (room) {
                        counter++;
                    }
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    synchronized (room) {
                        counter--;
                    }
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter);
    }
}

我们可以做这样的类比

  • synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人 进行计算，线程 t1，t2 想象成两个人
  • 当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行 count++ 代码
  • 这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切 换，阻塞住了
  • 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦）， 这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才 能开门进入
  • 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥 匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码

image-20230112174846138

synchronized 实际上是用 对象锁 保证了 临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断

为了加深理解，请思考下面的问题：

  • 如果把 synchronized (obj) 放在 for 循环的外面，如何理解？

这样的话就不会出现两个线程交替执行的情况，只有当一个线程执行完后另一个线程才会执行。

  • 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？

synchronized是给对象加锁，两个线程用不同的对象加锁那么就不会出现两个线程竞争锁对象的情况，相当于两个线程都没有加锁，那么就会出现线程安全问题。

  • 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象

线程1加了锁，线程2不加，那就相当于两个线程都没加，还是会出现线程安全问题。

面向对象改进

public class Main {

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    synchronized (room) {
                        room.increment();
                    }
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5000; i++) {
                    synchronized (room) {
                       room.decrement();
                    }
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(room.get());
    }
}
class Room {
    int value = 0;
    public void increment() {
        synchronized (this) {
            value++;
        }
    }
    public void decrement() {
        synchronized (this) {
            value--;
        }
    }
    public int get() {
        synchronized (this) {
            return value;
        }
    }
}

这里的锁对象是this也就是room这个对象实例。

4 线程八锁

我们前面说过

  1. synchronized作用于成员变量和非静态方法时，锁住的是对象的实例，即this对象

  2. synchronized作用于静态方法时，锁住的是Class实例

  3. synchronized作用于一个代码块时，锁住的是所有代码块中配置的对象

所以

class Test {
    public synchronized void test() {

    }
}
、、 等价于
class Test {
    public void test() {
        synchronized (this) {

        }
    }
}

// 这两个锁的都是对象的实例，即this对象

class Test{
 public synchronized static void test() {
 }
}
// 等价于
class Test{
 	public static void test() {
 		synchronized(Test.class) {
 
 		}
 	}
}
// 锁的是类实例

所谓的“线程八锁”其实就是考察synchronized锁住的是哪个对象

情况1

class Number {
    public synchronized void a() {
        System.out.println("1");
    }

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

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        new Thread(() -> {number.b();}).start();
        new Thread(() -> {number.a();}).start();
    }
}

答案是 1 2 或 2 1

这里方法a和方法b锁的都是 number这个对象，所以两个线程之间是竞争同一把锁。

情况2

class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

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

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        new Thread(() -> {number.a();}).start();
        new Thread(() -> {number.b();}).start();
    }
}

答案是 1s后1 2 或 2 1s后1

这里两个线程仍然竞争的是number这同一把锁，线程1拿到锁之后，执行的是sleep方法，虽然放弃了cpu的使用，但并没有放弃锁对象，所以线程2还是获取不到锁，所以必须是一个线程执行完后一个线程才能获取到锁。

情况3

class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

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

    public void c()
    {
        System.out.println("3");
    }
}

public class Test {
    public static void main(String[] args) {
        Number number = new Number();
        new Thread(() -> {number.a();}).start();
        new Thread(() -> {number.b();}).start();
        new Thread(() -> {number.c();}).start();
    }
}

答案：3 1s后1 2 或 2 3 1s后1 或者 3 2 1s后1

线程3不去竞争锁对象。当线程3先执行时，不去竞争锁，直接执行。线程1和线程去竞争同一把锁。

情况4

class Number {
    public synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

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

}

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

答案：2 1s后1

这里线程1竞争的是n1,线程2竞争的是n2，所以两个线程之间竞争的不是同一把锁，所以它俩之间不存在互斥。

情况5

class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

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

}

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

答案： 2 1s后1

线程1竞争的是Number实例，而线程2竞争的是n1，所以它俩竞争的不是同一把锁。

情况6

class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

    public static synchronized void b() {
        System.out.println("2");
    }
    
}

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

答案：1s后1 2 或 2 1s后1

这里线程1和线程2竞争的都是 Number

情况7

class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

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

}

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

答案： 2 1s后1

这里线程1竞争的是Number实例，线程2竞争的是n2,它俩竞争的不是同一个对象锁。

情况8

class Number {
    public static synchronized void a() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("1");
    }

    public static synchronized void b() {
        System.out.println("2");
    }

}

public class Test {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

答案： 1s后1 2 或 2 1s后1

这里线程1和线程2竞争的都是 Number

在这里插入图片描述

好了，线程八锁的问题就说到这了，后续还会继续更新！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/159513.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

STM32单片机CAN总线汽车自动会车灯远近光切换

STM32单片机CAN总线汽车自动会车灯远近光切换

实践制作DIY- GC0121-汽车自动会车灯 一、功能说明&#xff1a; 基于51单片机设计-汽车自动会车灯 功能介绍&#xff1a; OLED主控板&#xff1a;STM32F103C系列最小系统OLED显示3个按键&#xff08;开关、自动/手动、近光/远光&#xff09;CAN通讯模块 光敏LED板&#xff1a…
阅读更多...
房产管理系统架构分析

房产管理系统架构分析

数图互通高校房产管理系统是基于公司自主研发的FMCenterV5.0平台&#xff0c;是针对中国高校房产的管理特点和管理要求&#xff0c;研发的一套标准产品&#xff1b;通过在中国100多所高校的成功实施和迭代&#xff0c;形成了一套成熟、完善、全生命周期的房屋资源管理解决方案。…
阅读更多...
你的示波器只能抓到5%的波形？

你的示波器只能抓到5%的波形？

采样时间、死区时间和捕获时间 数字示波器捕获信号的过程是典型的“采集-处理-采集-处理”&#xff0c;如图1所示为数字示波器的采集原理&#xff0c;一个捕获周期由采样时间和处理时间&#xff08;死区时间&#xff09;组成&#xff0c;如图2所示。 图1 示波器采集原理图 采…
阅读更多...
Redis String 命令与实战

Redis String 命令与实战

在前面的文章中&#xff0c;我们了解了 Redis 的基本功能&#xff0c;通过源码方式安装了 Redis&#xff0c;并搭建了 Redis 的源码运行环境。接下来将进入 “Redis 的实战应用篇”&#xff0c;在这部分我们将重点介绍 Redis 核心命令的使用&#xff0c;主要包括 Redis 中 Stri…
阅读更多...
磨金石教育摄影技能干货分享｜摄影师镜头下生活的色彩

磨金石教育摄影技能干货分享｜摄影师镜头下生活的色彩

在生活中也有很多亮丽的色彩&#xff0c;生活在我们看起来是平凡的&#xff0c;但其实每个地方每个人都会有不同的风景。不同的文化&#xff0c;不同的地域&#xff0c;这些都足以构造出不同的色彩。下面就让我们跟随镜头看看世界各地人民多姿多彩的生活。1 生活的色彩这是西孟…
阅读更多...
ASP .Net Core内置 Identity 简介 使用

ASP .Net Core内置 Identity 简介 使用

一、简介 1、概况 ASP.NET Core Identity是一个成员身份系统&#xff0c;可将用户注册和登录功能添加到 ASP.NET Core Web UI。 成员身份系统处理身份验证和授权问题。 身份验证涉及你的身份。 授权涉及允许你进行的操作。 因此&#xff0c;身份验证是授权的先决条件。 ASP .N…
阅读更多...
js判断 数组中是否存在形同元素

js判断 数组中是否存在形同元素

上例子 flag true; //假设不重复&#xff1b; let arr [{ settingName: 渠道客户订单, settingCode: A1 },{ settingName: 户订单, settingCode: A1 },];for(let i 0;i < arr.length-1;i){ //循环开始元素 for(let j i 1;j < arr.length;j){ //循环后续所有元素 …
阅读更多...
Pandoc 多Markdown转单PDF

Pandoc 多Markdown转单PDF

文章目录Pandoc 简介Pandoc 安装pandoc-latex-template字体安装Powershell 脚本Ubuntu PandocMarkdown 合并Pandoc 简介 Pandoc, 免费的文档转换器, 支持常见的各种文件格式的相互转换, 如Markdown, HTML, EPUB, LaTeX, docx, RTF, PDF 等. 本篇以Windows下的多Markdown转单P…
阅读更多...
个性化脑机接口及应用

个性化脑机接口及应用

脑机接口&#xff08;BCI&#xff09;是一种变革传统人机交互的新型技术&#xff0c;用户的大脑是直接的控制信号源。在BCI转化为实际应用时&#xff0c;由于用户个体之间的感觉、知觉、表象与认知思维活动、脑结构与功能具有一定的差异&#xff0c;通用BCI难以满足不同个体的需…
阅读更多...
国产linux操作系统——麒麟操作系统的来龙去脉(有下载地址，亲测可用)

国产linux操作系统——麒麟操作系统的来龙去脉(有下载地址，亲测可用)

文章目录1、linux操作系统2、国产操作系统3、麒麟操作系统4、引用1、linux操作系统 目前市场主流的linux操作系统分类大致如此&#xff0c;国产操作系统的麒麟操作系统&#xff0c;底层比较杂&#xff0c;所以单独一类。 2、国产操作系统 排名日期截止到2022.6。 这里提一下排…
阅读更多...
基于java SSM的房屋租赁系统设计和实现

基于java SSM的房屋租赁系统设计和实现

基于java SSM的房屋租赁系统设计和实现 博主介绍&#xff1a;5年java开发经验&#xff0c;专注Java开发、定制、远程、文档编写指导等,csdn特邀作者、专注于Java技术领域 作者主页 超级帅帅吴 Java毕设项目精品实战案例《500套》 欢迎点赞 收藏 ⭐留言 文末获取源码联系方式 文…
阅读更多...
ASO优化的两个渠道之推广+老用户维系

ASO优化的两个渠道之推广+老用户维系

要想自己的APP在应用商城里获得较高的排名&#xff0c;提高用户的下载量&#xff0c;就要通过ASO优化来辅助完成。 &#xff08;一&#xff09;&#xff0c;ASO优化的排名因素——元数据的优化&#xff1a;1&#xff0c;icon图标。图片要直观和清晰地突出APP的内容&#xff0c…
阅读更多...
力扣刷题记录——434. 字符串中的单词数、448. 找到所有数组中消失的数字、455. 分发饼干

力扣刷题记录——434. 字符串中的单词数、448. 找到所有数组中消失的数字、455. 分发饼干

本专栏主要记录力扣的刷题记录&#xff0c;备战蓝桥杯&#xff0c;供复盘和优化算法使用&#xff0c;也希望给大家带来帮助&#xff0c;博主是算法小白&#xff0c;希望各位大佬不要见笑&#xff0c;今天要分享的是——《434. 字符串中的单词数、448. 找到所有数组中消失的数字…
阅读更多...
Google colab-思腾云

Google colab-思腾云

文章目录Google colab具体操作过程问题1问题2AutoDL问题1 无卡开机思腾云使用基础信息如何租用服务器&#xff1f;如何上传代码以及运行程序&#xff1f;操作服务器的方式&#xff1f;pycharm方式Xshell的形式问题1 libSM.so.6 和 libXrender.so.1问题2&#xff1a;运行代码出现…
阅读更多...
Dubbo概述-快速入门

Dubbo概述-快速入门

Dubbo概念 ●Dubbo是阿里巴巴公司开源的一个高性能、轻量级的Java RPC框架。 ●致力于提供高性能和透明化的RPC远程服务调用方案,以及SOA服务治理方案。 ●官网: http://ubbo.apache.orgo 节点角色说明: . ●Provider: 暴露服务的服务提供方 ●Contahier: 服务运行容器 ●Co…
阅读更多...
YOLOv3论文精读: An Incremental Improvement-增量式的改进

YOLOv3论文精读: An Incremental Improvement-增量式的改进

Abstract 我们对 YOLO 进行了一系列更新&#xff01;它包含一堆小设计&#xff0c;可以使系统的性能得到更新。我们也训练了一个新的、比较大的神经网络。虽然比上一版更大一些&#xff0c;但是精度也提高了。不用担心&#xff0c;它的速度依然很快。YOLOv3 在 320320 输入图像…
阅读更多...
【Django项目开发】部门管理模块的开发（九）

【Django项目开发】部门管理模块的开发（九）

文章目录一、模型类设计二、视图设计1.都有哪些接口三、序列化器类设计四.分页操作1.utils工具中定义pagination.py2.视图类中使用五.路由配置一、模型类设计 一个部门下面可能会有很多子部门&#xff0c;一个子部门上面可能会有父部门&#xff1b;即部门内部之间进行关联&…
阅读更多...
Grapecity DataViewsJS JavaScript Crack

Grapecity DataViewsJS JavaScript Crack

Grapecity DataViewsJS一个完整的 React 数据展示和数据网格平台 通过从各种不同的演示视图中进行选择&#xff0c;包括树、卡片、砖石、网格、时间线、甘特图、日历和网格&#xff0c;超越传统的表格显示。采集 by Ω578867473 免费无限开发者许可&#xff01;只为部署付费 快…
阅读更多...
Hexo博客搭建（简化版）

Hexo博客搭建（简化版）

Hexo博客搭建&#xff08;简化版&#xff09; 一、环境搭建 1.1 Git Git官网-下载界面 > git --version1.2 Node.js 1.2.1 下载安装Node.js Node.js官网下载界面 > node --version1.2.2 Hexo与Node.js Hexo versionMinimum (Node.js version)Less than (Node.js …
阅读更多...
2023年我花费数小时整理的Java常用类文档，建议收藏学习

2023年我花费数小时整理的Java常用类文档，建议收藏学习

推荐学习专栏&#xff1a;【Java 编程基础教程系列】&#xff0c;从入门到就业精通&#xff0c;买不了吃亏&#xff0c;买不了上当&#xff01;&#xff01; 文章目录1. 基本类型的包装类1.1 概念1.2 常用的属性1.3 常用的方法1.4 自动装箱和自动拆箱2. 字符串类2.1 String 类2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023