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

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

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线程同理,就不会出现死锁了。

一文搞懂core-scheduling核心机制 一文搞懂core scheduling的工作核心机制 阅读详情

相关推荐

S.BUS协议及编解码,C语言源码

1、简介 SBUS本质是一种串口通信协议,采用100K的波特率,8位数据位,两位停止位,偶效验,即8E2的串口通信。 值得注意的有三点: 1.SBUS采用负逻辑,所以无论接收还是发送都要进行硬件取反(注意,一定要硬件取反),电路如下 这是我在网上看资料时看到的电路,实际上我用的是下面这个电路 2.SBUS有两种模式, a.高速模式:每4ms发送一次 b...

qq_31232793的博客 1万+

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

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

weixin_39855843的博客 613

【UV打印机】PrintExp打印软件教程(二)-主界面介绍

PrintExp软件主界面如下图所示PrintExp软件的主界面主要包括主菜单区,工具栏区,界面显示区,状态栏。以下是上述部分的介绍。

Print World的专栏 6303

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

Java内存模型 线程同步 线程同步机制是一套适用于协调线程之间的数据访问机制,该机制可以保障线程安全 java平台提供的线程同步机制包括:锁、volatile关键字、final关键字,static关键字、以及相关API如object.wait/object.notify 锁概述 线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。 线程访问数据时必须先获得锁,获得锁的线程称为锁的持有线程,一个锁

Java圈全能架构师的博客 407

239号资源-simulink仿真:MATLAB/Simulink教程(PDF文档)-----已提供下载资源

电网论文源程序擅长文章解读,论文与完整源程序,等方面的知识,电网论文源程序关注python,机器学习,计算机视觉,深度学习,神经网络,数据挖掘领域.电网论文源程序擅长文章解读,论文与完整源程序,等方面的知识,电网论文源程序关注python,机器学习,计算机视觉,深度学习,神经网络,数据挖掘领域.《《《《《《《《更多资源还请持续关注本专栏》》》》》》》《《《《《《《《更多资源还请持续关注本专栏》》》》》》》论文与完整源程序_电网论文源程序的博客-优快云博客。电网论文源程序-优快云博客。

LIANG674027206的博客 1076

使用MKL+Eigen求解稀疏矩阵方程组

问题:求解Ax=b的解,其中,A为大型稀疏矩阵,长和宽分别为1500^2。 一般思路: (1)A为对称正定矩阵,对A使用cholesky分解。 (2)A为对称不定矩阵,使用LDL‘分解,即: PAP'=LDL' 其中,L为单位下三角矩阵,D由阶数为1或者2的对角块构成,P是置换矩阵。 (3)不对称矩阵:LU分解。 (4)长方形矩阵(长...

薛晓伟 3446

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

多线程之间的request信息

baidu_37366055的博客 1941

适合初学者的ROS机器人教程(1): Ubuntu下ROS创建自己的包和使用github下载的包

ROS如何创建自己的包 1. 首先创建catkin工作空间(如果你以及有了请忽略) $ mkdir catkin_ws # 创建一个文件夹里面计划放我们的项目,ws是workspace的缩写 $ cd catkin_ws # 将当前工作文件夹切换到catkin_ws这个文件夹 ~/catkin_ws$ catkin_make # 执行catkin_make创建一ROS项目 此时你的catkin_...

@司南牧|知乎|博客|易懂教程|李韬 3245

Java:26-多线程

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

qq_59609098的博客 2658

【QT】基于QSerialPort的跨平台串口通信实战指南

本文是一份基于Qt QSerialPort模块的跨平台串口通信实战指南。详细介绍了从硬件基础、QSerialPort核心类使用、参数配置、设备自动发现到数据异步读写和错误处理的完整流程,并通过构建一个功能齐全的串口调试助手实例,帮助开发者快速掌握在Windows、Linux和macOS系统下进行高效、稳定的串口应用开发。

a1b2c3d的博客 983

基于STM32L4XX、HAL库的RTL8201F 以太网收发器(PHY)驱动程序设计

define PHY_RESET_DELAY 1000 // PHY复位延迟(ms)#define PHY_AUTONEGO_DELAY 3000 // 自动协商延迟(ms)/* 检查PHY ID (RTL8201F的ID为0x001CC816) *//* 系统时钟配置,确保ETH有50MHz时钟 *//* 初始化CPU, AHB和APB总线时钟 */

zhusl6688的博客 817

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

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

2303_77877769的博客 1109

YOLO11涨点优化:知识蒸馏 | 引入FGD(Focal and Global Distillation)蒸馏,让轻量学生模型汲取大模型全局感知力

文章摘要 目标检测模型YOLO11在轻量化部署中存在"全局盲区"问题,即轻量模型感受野不足导致大尺度场景下性能下降。知识蒸馏技术FGD(Focal and Global Distillation)通过双分支机制有效解决这一问题:Focal Distillation分离前景背景特征,让学生模型聚焦关键区域;Global Distillation传递像素间关系信息,弥补全局感知缺陷。实验表明,FGD可使YOLO11轻量版mAP提升2.5%以上,且不增加推理耗时。本文详细解析了FGD原理,并给出YOLO11上的实

2601_95807009的博客 238

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

Java内存模型 线程同步 线程同步机制是一套适用于协调线程之间的数据访问机制,该机制可以保障线程安全 java平台提供的线程同步机制包括:锁、volatile关键字、final关键字,static关键字、以及相关API如object.wait/object.notify 锁概述 线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。 线程访问数据时必须先获得锁,获得锁的线程称为锁的持有线程

m0_64821673的博客 181

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

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

线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。线程访问数据时必须先获得锁,获得锁的线程称为锁的持有线程,一个锁一次只能被一个线程持有,持有线程在获得锁之后和释放锁之前锁执行的代码称之为临界区。锁具有排它性(Exclisive),即一个锁只能被一个线程持有,这种锁称为排它锁或者互斥锁。JVM部分把锁分为内部锁和显示锁,内部锁通过Synchronized关键字实现,显示锁通过。

m0_63437643的博客 88

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

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

Java内存模型线程同步线程同步机制是一套适用于协调线程之间的数据访问机制,该机制可以保障线程安全java平台提供的线程同步机制包括:锁、volatile关键字、final关键字,static关键字、以及相关API如object.wait/object.notify锁概述线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。

m0_63437643的博客 132

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

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

Java内存模型 线程同步 线程同步机制是一套适用于协调线程之间的数据访问机制,该机制可以保障线程安全 java平台提供的线程同步机制包括:锁、volatile关键字、final关键字,static关键字、以及相关API如object.wait/object.notify 锁概述 线程安全问题的产生前提是多个线程并发访问共享数据,将多个数据对共享数据的并发访问,转化为串行访问,即共享数据只能被一个线程访问,锁就是这种思路。 线程访问数据时必须先获得锁,获得锁的线程称为锁的持有线程

fk_99的博客 147
上一篇: CTO问我Pulsar到底能不能取代Kafka
下一篇: MySQL-SQL优化10大最经典案例详解
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值