涨姿势了!原来这才是多线程正确实现方式

避免资源泄漏!C#多线程任务取消的正确姿势(CancellationToken详解) 本文深入解析C#中CancellationToken在多线程任务取消中的正确使用方法,帮助开发者避免资源泄漏问题。通过介绍CancellationToken的核心机制、四种实现模式及高级应用场景,提供了一套完整的任务取消解决方案,特别适合处理高并发环境下的异步任务管理。 阅读详情

Java内存模型

 

线程同步

线程同步机制是一套适用于协调线程之间的数据访问机制,该机制可以保障线程安全

java平台提供的线程同步机制包括:锁、volatile关键字、final关键字,static关键字、以及相关API如object.wait/object.notify

锁概述

线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。

线程访问数据时必须先获得锁,获得锁的线程称为锁的持有线程,一个锁一次只能被一个线程持有,持有线程在获得锁之后和释放锁之前锁执行的代码称之为临界区。

锁具有排它性(Exclisive),即一个锁只能被一个线程持有,这种锁称为排它锁或者互斥锁。

JVM部分把锁分为内部锁和显示锁,内部锁通过Synchronized关键字实现,显示锁通过
java.concurrent.locks.Lock接口实现类实现的。

锁的作用

锁能够实现对共享数据的安全,保障线程的原子性,可见性与有序性。

锁是通过互斥保障原子性,一个锁只能被一个线程持有,这就保证了临界区的代码一次只能被一个线程执行,使得临界区代码所执行的的操作自然而然的具有不可分割的特性,既具备了原子性。

好比一条路段所有车辆都在跑,并发执行,在经过某一个路段的时候,多车道变为一车道,一次只能通过一辆车,由并发执行改为串行执行。

可见性是通过写线程冲刷处理器的缓存和读线程刷新处理器缓存这两个动作,锁的获得隐含着刷新处理器缓存的动作,锁的释放隐含着冲刷处理器缓存的动作。

锁能够保障有序性,写线程在临界区所执行的临界区看来像是完全按照源码顺序执行的。

锁的相关概念

可重入性:一个线程持有该锁的时候能够再次/多次申请该锁

如果一个线程持有一个锁的时候,还没有释放,但还能够继续成功申请该锁,称该锁可重入,反之。

锁的争用与调度

java中内部锁属于非公平锁,显示锁支持非公平锁和公平锁

锁的粒度

一个所可以保护的共享数据的数量大小称为锁的粒度。

锁保护共享数据量大,称为锁粒度粗,否则称为粒度细。

锁的粒度过粗会导致线程在申请锁时会进行不必要的等待,锁粒度过细会增加锁调度的开销。

比如银行有一个柜台一个员工可以办理开卡、销户、取现、贷款那么所有人都只能去这个柜台办理业务,会需要很长的等待时间。但是如果把业务细分,一个业务一个柜台,这时候增加了银行的开销,需要三个员工。

内部锁:Synchronized

Java中每一个对象都有一个与之关联的内部锁,这种锁也叫监视器,是一种排它锁,可以保障原子性、可见性、排它性。

Synchronized(对象锁)
{
  同步代码块,可以在同步代码块中访问共享数据
}

修饰实例方法称为同步实例方法,修饰静态方法称为同步静态方法。

Synchronized同步代码块

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        for (int i = 0; i <2 ; i++) {
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();
                }
            }.start();
        }
    }
    public  void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

两个线程的代码都在并发执行

现在要打印的时候进行同步,同步的原理线程在执行的时候要先要获得锁

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        for (int i = 0; i <2 ; i++) {
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        }
    }
    public  void  mm()
    {
        synchronized (this)//this作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

因为Synchronized内部锁是排它锁,一次只能被一个线程持有,现在是Thread-0先取得锁对象,Thread-1在等待区等待Thread-0执行完毕释放锁,Thread-1获得锁再执行。

锁对象不同不能实现同步


public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        SynchronizedLock synchronizedLock2=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock2.mm();//使用锁的对象是synchronizedLock对象
            }
        }.start();
    }
    public  void  mm()
    {
        synchronized (this)//this作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

因此想要同步必须使用同一个锁对象

使用常量作为锁对象


public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        SynchronizedLock synchronizedLock2=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();//使用锁的对象是synchronizedLock对象
            }
        }.start();
    }
    public  static  final  Object obj=new Object();
    public  void  mm()
    {
        synchronized (obj)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步实例方法

使用synchronized修饰实例方法,同步实例方法,默认使用this作为锁对象

public class SynchronizedLock {
   public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
            new Thread(new RunnableThread())
            {
                @Override
                public void run() {
                    synchronizedLock.mm();
                }
            }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() { 
                synchronizedLock.mm2();
            }
        }.start();
    }
    //同步实例方法
    public  synchronized void  mm()
    {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
    }
    public  void  mm2()
    {
        synchronized (this)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步静态方法

使用synchronized修饰静态方法,同步静态方法,默认运行时使用SynchronizedLock class作为锁对象

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm2();
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                SynchronizedLock.mm();//使用锁的对象是SynchronizedLock.class
            }
        }.start();
    }
    //同步静态方法
    public  synchronized static void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
    public  void  mm2()
    {
        synchronized (SynchronizedLock.class)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步代码块和同步方法如何选择

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                try {
                    synchronizedLock.mm2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                try {
                    synchronizedLock.mm2();//使用锁的对象是SynchronizedLock.class
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
    //同步实例方法 锁的粒度粗 执行效率低
    public  synchronized  void  mm() throws InterruptedException {
        long starttime= System.currentTimeMillis();
        System.out.println("start");
        Thread.sleep(3000);
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
        System.out.println("end");
        long Endtime= System.currentTimeMillis();
        System.out.println(Endtime-starttime);
    }
    //同步代码块 锁的粒度细 并发效率高
    public  void  mm2() throws InterruptedException {
        System.out.println("start");
        Thread.sleep(3000);
        synchronized (this)//常量作为当前对象
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
        System.out.println("end");
    }
}

在执行同步方法的时候,两次线程调用每次都需要休眠三秒,而同步代码块同时启动线程都先准备三秒,效率比较高

脏读

public class Test06 {
    public static void main(String[] args) throws InterruptedException {
        User user=new User();
        SubThread subThread=new SubThread(user);
        subThread.start();
        user.GetName();
    }
    static  class SubThread extends Thread
    {
        public User user;

        public SubThread(User user)
        {
            this.user=user;
        }

        @Override
        public void run() {
            user.SetValue("ww","456");
        }
    }
    static  class  User
    {
        private  String name="ylc";
        private  String pwd="123";
        public  void  GetName()
        {
            System.out.println(Thread.currentThread().getName()+"==>"+name+"密码"+pwd);
        }
        public  void  SetValue(String name,String pwd)
        {
            System.out.println("原来为为name="+this.name+",pwd="+this.pwd);
            this.name=name;
            this.pwd=pwd;
            System.out.println("更新为name="+name+",pwd="+pwd);
        }

    }
}

在修改数据还没有完成的时候,就读取到了原来的数据,而不是修改之后的

出现脏读的原因是对共享数据的修改和读取不同步引起的

解决办法是对修改和读取的方法进行同步方法上加上synchronized关键字

线程出现异常释放锁

假如在同步方法中,一个线程出现了异常,会不会没有释放锁,其他在等待的线程就在一直等待,论证:

public class SynchronizedLock {
    public static void main(String[] args) {
        SynchronizedLock synchronizedLock=new SynchronizedLock();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm();
            }
        }.start();
        new Thread(new RunnableThread())
        {
            @Override
            public void run() {
                synchronizedLock.mm2();
            }
        }.start();
    }
    //同步实例方法
    public  synchronized void  mm()
    {
        for (int i = 0; i <100 ; i++) {
            if(i==50)
            {
                Integer.parseInt("abc");//异常设置
            }
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
    public  void  mm2()
    {
        synchronized (this)
        {
            for (int i = 0; i <100 ; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }
    }
}

同步过程中线程出现异常,会自动释放锁对象,以供下一个线程继续执行

死锁

多线程中可能需要使用多个锁,如果获取锁的顺序不一致,可能导致死锁。

public class Text06_5 {
    public static void main(String[] args) {
        SubThread subThread=new SubThread();
        SubThread subThread2=new SubThread();
        subThread.setName("a"); subThread2.setName("b");
        subThread.start();subThread2.start();
    }
    static  class SubThread  extends  Thread
    {
        private  static  final Object lock1=new Object();
        private  static  final Object lock2=new Object();

        @Override
        public void run() {
            if("a".equals(Thread.currentThread().getName()))
            {
                synchronized (lock1)
                {
                    System.out.println("a 线程 lock1获得了锁,再需要获得lock2");
                    synchronized (lock2)
                    {
                        System.out.println("a 线程 lock2获得了锁");
                    }
                }
            }

            if("b".equals(Thread.currentThread().getName()))
            {
                synchronized (lock2)
                {
                    System.out.println("b 线程 lock2获得了锁,再需要获得lock1");
                    synchronized (lock1)
                    {
                        System.out.println(" b 线程 lock1获得了锁");
                    }
                }
            }
        }
    }
}

程序还在运行,却进入了卡死状态,a线程得到了lock1,要想把该线程释放的执行下面的代码获取lock2,而lock2被b线程获取无法释放,出现了鹬蚌相争的情况。

避免死锁:当需要获得锁时,所有线程获得锁的顺序一致,a线程先锁lock1,再锁lock2,b线程同理,就不会出现死锁了。

java多线程请求同一接口,模拟高并发 1、多线程工具TreadTestHttp package com; import java.util.concurrent.CountDownLatch; public class TreadTestHttp { public static void main(String[] args) throws InterruptedException { Runn... 阅读详情

相关推荐

向量化和向量数据库的开发步骤,以及本地docker下载Redis-stack-server,以及如何将文本转成向量,以及文本向量化成功后将数据存入到Redis-stack-server这个向量数据库

内存可以作为向量数据库,但是一重启一断电数据就没了这了选择RedisStack作为向量数据,用来向量的存储,未来会改名成Redis8,也就是在原本的Reids的功能上增加了新的特性,本质上还是Redis向量数据库还可以用ElaticSearch、MongoDB等。

qq_61723836的博客 1086

多线程不重复读取数据_Java高级编程基础:详解引用变量原子性读写实现多线程并发...

Java高级编程多线程并发操作原子性我们知道CPU在执行我们的每个线程单元代码指令时需要将固定长度的数据比如32位读入其寄存器,然后进行操作,然后被新的操作数据置换出来,如此每次操作的最小单位,而且这种操作无法被中断,被称为原子操作。我们从代码执行的设计上对于复杂资源的访问,特别是当有多个线程共同操作同一个共享资源时,必须保证每次只能有一个线程独占方式操作它。在编程时体现在与操作相关的代码部分必须...

weixin_39855843的博客 613

CentOS7下Graylog3.0高效日志管理:从零搭建到实战应用

本文详细介绍了在CentOS7操作系统上从零开始搭建Graylog3.0日志管理平台的完整过程。内容涵盖Java环境准备、MongoDB与Elasticsearch依赖安装、Graylog Server核心配置,并实战演示了通过Graylog Sidecar集中管理日志采集器以及配置邮件告警功能,为中小型团队提供了一个比ELK更轻量、易维护的一体化日志解决方案。

weixin_29207149的博客 88

多线程之间获取不到值的问题

多线程之间的request信息

baidu_37366055的博客 1941

ASP.NET Core Identity + Mysql(实战一)——注册登陆

在进行实战之前,我们先来了解一下Identity。 ASP.NET Core Identity是用于构建ASP.NET Core Web应用程序的成员资格系统,包括成员资格、登录和用户数据存储。简单的来讲包括: 1.用户数据存储(使用任意你喜欢的关系型数据库,从sqllite到mysql、sqlserver等等,由Entity Framwork 支持) 2.登陆、注册外加身份认证(基于coo...

weixin_40359716的博客 1401

别再只盯着轨迹线了!FLUENT DPM后处理实战:从粒子采样到直方图报告的完整流程

本文详细介绍了FLUENT DPM后处理的完整流程,从粒子采样到直方图报告的实战技巧。通过设置采样面、分析.dpm文件数据以及创建加权直方图,帮助工程师获取粒子速度、粒径分布等定量信息,提升多相流模拟的深度分析能力。特别适合需要超越轨迹线分析的CFD工程师。

weixin_28730353的博客 280

Java:26-多线程

Thread() ,使用无参的方式构造对象 Thread(String name) ,根据参数指定的名称来构造对象 Thread(Runnable target) ,根据参数指定的引用来构造对象,其中 Runnable 是个接口类型 Thread(Runnable target , String name) ,根据参数指定引用和名称来构造对象 void run() ,若使用 Runnable 引用构造了线程对象,调用该方法时最终调用接口中的版本。

qq_59609098的博客 2658

ICC 实战解析——CTS 时钟树综合中的关键设置与优化策略

本文深入解析ICC工具中CTS时钟树综合的关键设置与优化策略,涵盖时钟树异常引脚设置、目标参数配置、非默认布线规则(NDR)等核心技术。通过实战案例展示如何有效控制时钟偏差、优化信号完整性,并平衡功耗与面积,为芯片物理设计提供专业指导。

weixin_30872577的博客 328

涨姿势了!原来这才是Java多线程正确的实现方式!

多线程的优势-增加运行速度可以观察下面这个多线程例程,体验多线程时如何增加运行速度的。该代码运行结果如下:可见,多线程的优势,可以增加运行速度,缩短运行时间的。线程的创建方式,动手接触线程(三类六种)第一类:继承Thread类来实现线程的创建(2种创建方式)第一类:继承 Thread 类创建方法1@Override//线程执行的任务System.out.println("线程名称: " +System.out.println(“当前线程的名称(主线程):” +//创建了线程。

2303_77877769的博客 1109

【模型实战】MiMo-VL-7B讲解与实战

维度成绩MMMU70.6(图像理解最难测试之一)VideoMME70.8(视频理解标杆)59.4(超越78B参数模型)56.1(超过专用GUI模型)Elo评分开源VLM排名第一(7B~72B)社区热度过去一个月下载超1,600次(RL+SFT)📌一句话概括MiMo-VL 是目前性能最强、推理最稳、体验最佳、生态最全的7B级开源视觉语言模型。

m0_47867638的博客 1201

YOLOv11改进策略【卷积层】| 引入注意力卷积模块RFAConv,关注感受野空间特征 助力yolov11精度提升

RFAConv:创新空间注意力和标准卷积运算感受野空间特征是针对卷积核设计的,根据卷积核大小动态生成。以3×3卷积核为例,它由非重叠滑动窗口组成,每个窗口代表一个感受野滑块。

Limiiiing的博客 1824

长姿势了,原来这才是多线程的正确实现方式!

今天凌晨3点,狗哥给我发了消息(上图)让我回忆起了2016年末自己的亲身经历彼时,小编工作刚满两年,准备跳槽自以为小有所成,剑指大厂offer然而...(这是一个悲伤的故事)初见面试官的...

Java后端技术 457

Simulink开发项1000例实战专栏--实例148:构建一个完整的电动汽车电池SOH评估仿真模型,包括电池建模模块、数据采集模块、SOH估算算法模块以及性能评估模块

电动汽车的动力电池是其核心部件,而电池的健康状态(State of Health, SOH)直接影响车辆的续航能力和使用寿命。SOH通常定义为当前电池容量与初始容量的比值,用百分比表示。通过基于MATLAB/Simulink平台的SOH评估仿真,可以实时监测电池的退化情况,并为电池管理系统(BMS)提供决策依据。本项目旨在构建一个完整的电动汽车电池SOH评估仿真模型,包括电池建模模块、数据采集模块、SOH估算算法模块以及性能评估模块,并通过仿真验证SOH评估的准确性。

xiaoheshang_123的博客 342

【实战剖析】深入ThreadLocal核心原理,彻底消灭多线程Bug!

本文深入剖析ThreadLocal的核心原理与应用。ThreadLocal通过为每个线程创建变量副本,实现线程隔离的数据共享机制。其底层通过ThreadLocalMap存储数据,ThreadLocal对象作为key。文章通过对话形式讲解ThreadLocal基础用法,解析源码实现,并指出其潜在的内存泄漏风险及解决方案(及时remove、static修饰等)。ThreadLocal特别适合Web请求上下文传递、线程安全变量管理等场景,正确使用能有效解决多线程并发问题。

doke99的博客 1000

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

JNI/NDK入门指南之正确姿势了解,使用,管理,缓存JNI引用

      JNI/NDK入门指南之正确姿势了解JNI引用 前言   对于本篇我是写了删,删了又写,当然不是我纠结于我的文笔不好。而是因为本章涉及的知识面比较广,而我如果由于个人原因不能将JNI中的引用讲得透彻明白甚至误导了读者的话,那就是最大的罪过了!但是又不得不写,因为如果想真正的将JNI用于实战而不是仅仅的了解,那么JNI的引用是逃脱不了的。所以我只能硬着头皮上了,力求讲明白,如果有...

IT先森 1867

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

如何正确的跳槽涨薪?GitHub中文社区这份Java面试八股文,告诉如何你正确的姿势

今天讲讲跳槽。金九银十快到了,一些不满现状,被外界的“高薪”“好福利”吸引的人,一般就在这时候毅然决然地跳槽了。跳槽是为了寻求更好的发展,但在跳槽前我们也不能确定下家就是更好的归宿,这就更加需要我们审慎地去对待,不能盲目跳槽。其次,我们离职和跳槽,其中的原因很大一部分是目前薪资不符合预期。那么首先就要搞清楚,收入是由什么决定的?答案是:价值。为所在公司创造的价值。经常有从事Java开发多年的软件工程师,跳槽时却可能面临连面试机会都很难得到的窘境。

m0_73311735的博客 62

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

【分布式缓存系列】Redis实现分布式锁的正确姿势

【分布式缓存系列】Redis实现分布式锁的正确姿势 一、前言   在我们日常工作中,除了Spring和Mybatis外,用到最多无外乎分布式缓存框架——Redis。但是很多工作很多年的朋友对Redis还处于一个最基础的使用和认识。所以我就像把自己对分布式缓存的一些理解和应用整理一个系列,希望可以帮助到大家加深对Redis的理解。本系列的文章思路先...

fgmah2000的博客 100

Android开发工程师正确选择面试的方式,要涨薪,先跳槽。

要涨薪,先跳槽”各个行业都存在这一共识,但是任何行业也都没有像程序员这样更为适用且好用的了。

老皮的博客 219
上一篇: Redis之RedisTemplate的序列化方式深入解读
下一篇: Spring Boot源码学习:自动配置与自定义注解详解
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值