静态方法加锁,和非静态方法加锁区别

synchronized 方法锁、对象锁、类锁区别 不加锁的情况 package com.example.demo.controller; import org.springframework.web.bind.annotation.RestController; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class AdminController { public static void m.. 阅读详情

原文地址:http://greemranqq.iteye.com/blog/1974143

今天看了到有意思的题:在静态方法上加锁 和 非静态方法加锁 有什么区别,从而再次引出锁机制的一些理解。
先看方法:

// 这是一个很简单的类,里面共享静态变量 num,然后一个静态 和 非静态方法,都加上锁
// 我们假设有两个线程同时操作这两个方法,那么数据能互斥吗?

Java代码

public class Walk {  
    public static int num = 100;  
    public static Walk walk = new Walk();  
    // 静态  
    public synchronized static   int run(){  
            int i = 0;  
            while (i < 10) {  
                try {  
                    num --;  
                    i++;  
                    System.out.println(Thread.currentThread().getName()+":"+num);  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            return num ;  
    }  
    // 非静态  
    public  synchronized int  walk(){  
            int i = 0;  
            while (i < 10) {  
                try {  
                    num --;  
                    i++;  
                    System.out.println(Thread.currentThread().getName()+":"+num);  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            return num ;  
    }  
}  
// 先建立两个测试类,这里我们默认循环10次  
public class T3 implements Runnable {  
    @Override  
    public void run() {  
        Walk walk = new Walk();  
        //Walk walk = Walk.walk;  
        walk.walk();  
    }  
}  

public class T1 implements Runnable{  
    @Override  
    public void run() {  
        Walk walk = new Walk();  
        //Walk walk = Walk.walk;  
        // 这里我依然用的new  
        walk.run();  
    }  
}  

Java代码

// 测试方法  
public class Test {  
    public static void main(String[] args) {  
        Thread t1 = new  Thread(new T1());  
        Thread t3 = new  Thread(new T3());  
        ExecutorService es = Executors.newCachedThreadPool();  
        es.execute(t1);  
        es.execute(t3);  
        es.shutdown();  
    }  
}  

// 测试数据 我就不完全列出了

pool-1-thread-1:98
pool-1-thread-2:98
pool-1-thread-2:97
pool-1-thread-1:96
…..
可以看出两个线程没有互斥,这是为什么呢?
OK,我们将static 关键字去掉,代码我就不贴了,直接看结果。。
pool-1-thread-1:98
pool-1-thread-2:98
pool-1-thread-2:96
…
结果还是没有出现互斥现象,因此我们默认要先让一个线程执行10次的,假设我们这个是买票系统这是不允许的。为什么会出现这状况呢,方法都加上的锁的。

这里先引一下锁的理解,然后从后向前解释。
JAVA 的锁机制说明:每个对象都有一个锁,并且是唯一的。假设分配的一个对象空间,里面有多个方法,相当于空间里面有多个小房间,如果我们把所有的小房间都加锁,因为这个对象只有一把钥匙,因此同一时间只能有一个人打开一个小房间,然后用完了还回去,再由JVM 去分配下一个获得钥匙的人。

第二次实验,我们是对方法进行加锁了,但是没得到想要的结果,原因在于房间与钥匙。因为我们每个线程在调用方法的时候都是new 一个对象,那么就会出现两个空间,两把钥匙,而静态变量只有一个,相当于我们有两把钥匙,从不同的房间开门取共享的值,因此出错。

如果我们使用静态变量walk 呢?这代码放开,也就是我们统一使用一个对象去操作变量,那么结果..

使用 Walk.walk.walk(); 和 Walk.run();

结果:还是没有互斥
pool-1-thread-1:99
pool-1-thread-2:98
pool-1-thread-1:97
…

如果我们把静态方法关键字 去掉: 就可以看见互斥现象了

pool-1-thread-1:99
pool-1-thread-1:98
pool-1-thread-1:96

结果发现还是会重复,因此我们可以得出,在静态方法上加锁,和普通方法上加锁,他们用的不是同一把所,不是同一把钥匙。从而得出 他们的对象锁是不同的,对象也是不同的。

这里再次引出一个概念:对象锁 和 类锁

对象锁:JVM 在创建对象的时候,默认会给每个对象一把唯一的对象锁,一把钥匙
类锁:每一个类都是一个对象,每个对象都拥有一个对象锁。

呵呵,概念感觉混淆了,其实都是锁,取两个名词,下面区分方便,效果是一样的,如果我们这样实现。

Java代码

// 静态,这里仅仅将方法所 变成了 类锁。  
    public  static int run(){  
        synchronized(Walk.class) {  
            int i = 0;  
            while (i < 10) {  
                try {  
                    num --;  
                    i++;  
                    System.out.println(Thread.currentThread().getName()+":"+num);  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            return num ;  
        }  
    }  

结果:
pool-1-thread-1:98
pool-1-thread-2:98
pool-1-thread-2:97
pool-1-thread-1:97
…
发现结果还是不是互斥的,说明在静态方法上加锁,和 实例方法加锁,对象锁 其实不一样的。如果我们改成:
synchronized(walk) {
//….略
}

结果:
pool-1-thread-2:99
pool-1-thread-2:98
pool-1-thread-2:97
这样就互斥了,因为T1 是通过静态变量walk 调用的,默认就是用的walk 对象这把锁,而静态方法 强制让他也使用 walk这把锁,就出现了互斥现象,因为钥匙只有一把。

如果我们两个方法都是静态方法呢?
..
小结:
1.对象锁钥匙只能有一把才能互斥,才能保证共享变量的唯一性
2.在静态方法上的锁,和 实例方法上的锁,默认不是同样的,如果同步需要制定两把锁一样。
3.关于同一个类的方法上的锁,来自于调用该方法的对象,如果调用该方法的对象是相同的,那么锁必然相同,否则就不相同。比如 new A().x() 和 new A().x(),对象不同,锁不同,如果A的单利的,就能互斥。
4.静态方法加锁,能和所有其他静态方法加锁的 进行互斥
5.静态方法加锁,和xx.class 锁效果一样,直接属于类的

SD卡烧写Linux kernel——SD卡分区,并烧写uboot,kernel,DTB及filesystem Linux Ubuntu环境下对SD卡分区(烧写uboot,kernel,及filesystem) 介绍dd命令的使用,SD卡分区、格式化、复制文件等 fdisk命令 阅读详情

相关推荐

移远EC20模块USB模式切换的底层逻辑与驱动适配探秘

本文深入探讨了移远EC20模块USB模式切换的底层逻辑与驱动适配机制,详细解析了AT命令控制下的USB0与WWAN0模式差异。通过分析USB协议栈、内核驱动框架及网络子系统的交互,提供了模式切换的完整操作流程和常见问题解决方案,助力开发者优化4G通信模块在嵌入式设备中的稳定连接。

cc789的博客 847

静态方法和非静态方法上加锁的区别

1.静态方法加锁:类锁 Synchronized修饰静态方法,实际上是对该类对象加锁,俗称“类锁” 2.非非静态方法加锁:对象锁 Synchronized修饰非静态方法,实际上是对调用该方法的对象加锁,俗称“对象锁” public class TestSyn { private static int num = 20; // 单例模式 静态内部类 public stat...

小泽的博客 2504

creo二次开发使用映射

在creo进行二次开发时,一些无法直接通过访问底层代码来对特征进行操作,比如“镜像装配”,这个时候就可以使用映射(Mapkey)来完成一键镜像。 注:这是镜像装配的代码 ProError status; ProMacro macro; wstring Macro; strMacro = L"mapkey(continued) ~ Command ProCmdMirrorAssem ; mapkey(continued) ~ Activate mirror_component_dialog Sy

qq_49328512的博客 1669

JAVA----静态方法上加锁 和 非静态方法加锁 区别

Synchronized修饰非静态方法,是对调用该方法的对象加锁,俗称“对象锁”。 这里的对象加锁并非是说执行该加锁方法的时候整个对象的所有成员都不允许其他线程访问了, 而是说该对象内所有的加锁的非静态方法共用这一把锁, 一个加锁非静态方法执行, 另一个加锁非静态方法不能执行,要等持有锁的线程释放锁, 不同对象之间的方法不互相作用 这里举第一个例子: 两个线程执行同一个对象的不同加锁非静态...

nO0b 8689

Android Qcom Display学习(十一)

该系列文章总目录链接与各部分简介:本章主要是基于MIPI Payload传输接口的学习,包括Generic和DCS的接口不同。底层都是基于去封装的,下面第一部分调用原生接口,第二部分分析高通是如何进行读写操作的。

Android驱动开发 3185

Palantir的本体论建模跟数仓建模的异同

Palantir的Foundry Ontology通过构建组织的数字孪生体,将数据集和模型映射为对象类型、属性、链接和操作类型,形成完整的语义知识网络。与传统数仓建模相比,本体建模以业务问题为驱动,强调细粒度语义和实时决策能力,采用图语义技术实现灵活的映射关系。

轩哥的个人研究和成长记录 1602

java静态方法 lock_静态方法加锁,和非静态方法加锁区别

今天看了到有意思的题:在静态方法上加锁 和 非静态方法加锁 有什么区别,从而再次引出锁机制的一些理解。先看方法:// 这是一个很简单的类,里面共享静态变量 num,然后一个静态 和 非静态方法,都加上锁// 我们假设有两个线程同时操作这两个方法,那么数据能互斥吗?Java代码publicclassWalk{publicstaticintnum=100;publicstaticW...

weixin_39603908的博客 1089

K8s(二十一):在 Kubernetes 集群中部署 MySQL8.0 高可用集群(1主2从)

🔴 K8s(二十一):在 Kubernetes 集群中部署 MySQL8.0 高可用集群(1主2从)

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 3万+

静态锁和非静态锁的区别

        静态锁: 在静态方法前面加上synchronized方法表示锁定此类,当多个线程调用这个类中的静态方法时会阻塞。         实例锁: 在实例方法前面加上synchronized方法表示锁定类的单个实例,当多个线程调用一个类申明的同一个实例的实例方法是会阻塞。        但静态锁和实例锁两者间的同步并不会受到互相干扰        首先什么是类锁?        就像可...

weixin_42630877的博客 3551

我的python学习之路

Python 是一门功能强大且易于学习的编程语言,广泛应用于数据分析、人工智能、Web 开发、自动化等领域。以下是一个 Python 学习路径的总结,帮助你系统地掌握 Python 编程。

数据知道的博客 3万+

【推荐100个unity插件】unity实现交互式火焰 —— Ignis

Ignis是一款Unity互动式消防系统插件,可轻松将物体转换为可燃物。支持固体、植被、蒙皮网格和地形树木等多种对象类型,提供火焰蔓延、熄灭等效果。安装需通过Unity Package Manager添加Visual Effects Graph,并按照指引转换目标物体材质。使用盒型碰撞体或网格计算燃烧区域,可自定义火焰参数和视觉效果。内置多种转换选项,如Flammable Vegetation、Flammable Skinned Mesh等,适用于不同场景需求。注意使用前需备份材质和地形数据,并提供性能优化

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 2243

jvm---静态方法加锁和非静态方法加锁的区别

静态方法加锁和非静态方法加锁的区别 静态方法加锁:static synchronized是类锁  非静态方法加锁:synchronized是对象锁 对象锁(又称实例锁,synchronized):该锁针对的是该实例对象(当前对象)。synchronized是对类的当前实例(当前对象)进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块,注意这里是“类的当前实例”, ...

Nagile-zhou博客 1973

基于MATLAB的变分模态分解(VMD)算法详解

变分模态分解(VMD)是一种先进的信号处理方法,通过变分框架将复杂信号分解为多个模态分量。相比传统经验模态分解(EMD),VMD具有坚实的数学基础,能有效抑制模态混叠和端点效应。其核心思想是将信号分解转化为约束优化问题,通过交替方向乘子法迭代求解各模态的中心频率和带宽。VMD在机械故障诊断、生物医学信号处理等领域展现出优越性能,尤其适合处理非平稳非线性信号。该算法通过严格的数学模型实现自适应频谱优化,为信号分析提供了更可靠的工具。

qq_42212808的博客 739

JAVA——静态方法加锁和非静态方法加锁的区别

对象锁(实例锁,synchronized) 该锁针对的是该实例对象(当前对象)。synchronized是对类的当前实例(当前对象)进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块。每个对象都有一个锁,且是唯一的。 注意: 1.指的是“类的当前实例”, 类的两个不同实例就没有这种约束了。 2.锁住的只是synchronized块,static synchroni...

qq_36470686的博客 2615

IMSL CNL 7.0.0 (x86-64)Crack

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

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

java synchronized静态_Java synchronized 非静态方法 静态方法的区别

package yi.test01;/*** @author yangwl*** synchronized作用于静态方法和非静态方法的区别:* 非静态方法:* 给对象加锁(可以理解为给这个对象的内存上锁,注意 只是这块内存,其他同类对象都会有各自的内存锁),这时候* 在其他一个以上线程中执行该对象的这个同步方法(注意:是该对象)就会产生互斥* 静态方法:* 相当于在类上加锁(*.class ...

weixin_39840733的博客 109

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

synchrpnized静态方法和非静态方法的区别

非静态方法:锁的是对象实例(对象锁)静态方法:锁的是类对象(类锁)

qq_64847107的博客 200

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

java 多线程的问题

转自http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html  例子讲的很生动,就是说每个对象的多个方法加锁的话,同一时间只能由一个线程访问该加锁的方法,另外其他线程也不能访问本对象的另外一个加锁

ning 756

Synchronized 知识

1.对非静态的方法加Synchronized 就是对这个对象加锁,如果是对static 加Synchronized 那就是对这个类加锁 2.对方法加锁和对代码块加锁效果一样,主要是考察锁的粒度 ...

weixin_43532323的博客 85
上一篇: 简析hashset的实现原理
下一篇: RDB和AOF持久化对比
anteoy
博客等级 码龄10年 24粉丝 83原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值