深入研究 synchronized 同步锁 作用于 静态方法 和 非静态方法 的 区别
1.前言
众所周知， synchronized 是同步锁 ，虽然在底层又细分了无锁、偏向锁、轻量级锁、自旋锁 以及重量级锁 机制，
这些底层锁知道一下原理即可 ，【想要 了解 这篇 博文 有 解释 ： https://blog.csdn.net/u013256816/article/details/51204385 】
我这篇随笔专门研究与总结 关于 synchronized 加 在 同一个类里的 静态 和非静态 方法前 有什么不一样的影响 。
这都是因为我看到的一道题引起的：
答案是 BE
我想问为什么？
查找博客资料 ，都是很笼统地解释
static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对
象），那么static获取到的锁，是属于类的锁。而非static方法获取到的锁，是属于当前对象
的锁。所以，他们之间不会产生互斥。
看的我一脸懵逼。。。。。。
当然可以清楚地知道
加了synchronized 且有static 的方法称为类锁，
没有static 的方法称为对象锁。
经过测试总结：
（1）多线程使用同一个对象，只允许同时使用一个对象锁，一个类锁，
其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；
（2）多线程分别 new 一个对象，允许同时使用任意的对象锁，也允许对象锁和
一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；
2.操作
（1）目录结构
（2）准备一个含有对象锁和类锁的 类
package com.example.javabaisc.lock;
public class MSynchronized {
public synchronized void method1(String name) throws InterruptedException {
int i = 0;
while (true) {
i++;
System.out.println(name + "我是方法1，当前数字是" + i);
if (i > 4) {
System.out.println(name + "我是方法1，退出");
break;
}
Thread.sleep(1000);
}
}
public synchronized void method2(String name) throws InterruptedException {
int i = 0;
while (true) {
i++;
System.out.println(name + "我是方法2，当前数字是" + i);
if (i > 4) {
System.out.println(name + "我是方法2，退出");
break;
}
Thread.sleep(1000);
}
}
public static synchronized void method3(String name) throws InterruptedException {
int i = 0;
while (true) {
i++;
System.out.println(name + "我是方法3，当前数字是" + i);
if (i > 4) {
System.out.println(name + "我是方法3，退出");
break;
}
Thread.sleep(1000);
}
}
public static synchronized void method4(String name) throws InterruptedException {
int i = 0;
while (true) {
i++;
System.out.println(name + "我是方法4，当前数字是" + i);
if (i > 4) {
System.out.println(name + "我是方法4，退出");
break;
}
Thread.sleep(1000);
}
}
}
（3）测试类
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
}
}
内容在测试里详细补充【注意，不可使用@Test注解启动 用户线程，否则所有线程都会随用户线程结束而结束】
3.测试
1）测试 ：多线程使用同一个对象
（1）同时使用同一个对象锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
//共用对象
MSynchronized mSynchronized = new MSynchronized();
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
mSynchronized.method1("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
（2）同时使用不同的的对象锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
//共用对象
MSynchronized mSynchronized = new MSynchronized();
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
mSynchronized.method2("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
（3）一个线程使用对象锁，一个使用类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
//共用对象
MSynchronized mSynchronized = new MSynchronized();
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
mSynchronized.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：可以同时使用
（4）同时使用同一个类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
//共用对象
MSynchronized mSynchronized = new MSynchronized();
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
mSynchronized.method4("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
mSynchronized.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
（5）同时使用不同的的类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
//共用对象
MSynchronized mSynchronized = new MSynchronized();
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
mSynchronized.method3("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
mSynchronized.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
===================================================================================
分割线
===================================================================================
2）测试 ：多线程分别 new 一个对象
（1）同时使用同一个对象锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
MSynchronized mSynchronized = new MSynchronized();
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
MSynchronized mSynchronized2 = new MSynchronized();
mSynchronized2.method1("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：可以同时使用
（2）同时使用不同的的对象锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
MSynchronized mSynchronized = new MSynchronized();
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
MSynchronized mSynchronized2 = new MSynchronized();
mSynchronized2.method2("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：可以同时使用
（3）一个线程使用对象锁，一个使用类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
MSynchronized mSynchronized = new MSynchronized();
mSynchronized.method1("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
MSynchronized mSynchronized2 = new MSynchronized();
mSynchronized2.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：可以同时使用
（4）同时使用同一个类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
MSynchronized mSynchronized = new MSynchronized();
mSynchronized.method4("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
MSynchronized mSynchronized2 = new MSynchronized();
mSynchronized2.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
（5）同时使用不同的的类锁
package com.example.javabaisc.lock;
public class SynT {
public static void main(String[] args){
Thread s1 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("=========我是线程1==========");
MSynchronized mSynchronized = new MSynchronized();
mSynchronized.method3("我是线程1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread s2 = new Thread(new Runnable() {
@Override
public void run() {
try {
// System.out.println("==========我是线程2========");
MSynchronized mSynchronized2 = new MSynchronized();
mSynchronized2.method4("我是线程2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//启动
s1.start();
s2.start();
}
}
打印结果
结论：互斥，不能同时使用
4.总结
（1）在多线程使用同一个对象的测试中，只允许同时使用一个对象锁，一个类锁，
其他操作搭配都互斥，只能等前一个线程解锁才能让下一个线程使用；
（2）在多线程分别 new 一个对象的测试中，允许同时使用任意的对象锁，也允许对象锁和
一个类锁同时使用，但是类锁不能够同时使用，会互斥，只能等前一个线程解锁才能让下一个线程使用；
深入研究 synchronized 同步锁 作用于 静态方法 和 非静态方法 的 区别的更多相关文章
- 在静态方法和非静态方法上加 Synchronized的区别
Synchronzied 修饰非静态方法==>对象锁 Synchronzied 修饰静态方法==>其实是类锁,因为是静态方法,它把整个类锁起来了: 1.Synchronized修饰非静态方 ...
- Java中synchronized用在静态方法和非静态方法上面的区别
synchronized 修饰在 static方法和非static方法的区别 在Java中,synchronized是用来表示同步的,我们可以synchronized来修饰一个方法.也可以sync ...
- 使用synchronized修饰静态方法和非静态方法有什么区别
前言 最近被问到了这个问题,第一次回答的也是很不好,在此参考网上答案进行整理记录.供大家学习参考. Synchronized修饰非静态方法 Synchronized修饰非静态方法,实际上是对调用该方法 ...
- java中静态方法和非静态方法调用的一点小困扰，已解决。
public static void main(String[] args) { // TODO Auto-generated method stub SimpleGui1B gui=new Simp ...
- Java中堆、栈，静态方法和非静态方法的速度问题
一.堆和栈的速度性能分析 堆和栈是JVM内存模型中的2个重要组成部分,自己很早以前也总结过堆和栈的区别,基本都是从存储内容,存储空间大小,存储速度这几个方面来理解的,但是关于堆和栈的存储 ...
- 转 C#中静态方法与非静态方法区别比较
C#静态方法与非静态方法的区别不仅仅是概念上的,那么他们有什么具体的区别呢?让我们通过本文向你做一下解析. C#的类中可以包含两种方法:C#静态方法与非静态方法.那么他们的定义有什么不同呢?他们在使用 ...
- C#静态类 静态方法与非静态方法比较
静态类 在类(class)上加入static修饰,表示该类无法被实例化,并将该类中,无法实例化变量或函数 静态类的主要特性 仅包含静态成员 无法实例化 静态类的本质,时一个抽象的密封类,所以不能被继承 ...
- [转]C#静态方法与非静态方法的比较
http://wenku.baidu.com/view/4e1704084a7302768e9939e0.html C#的类中可以包含两种方法:C#静态方法与非静态方法.那么他们的定义有什么不同呢?他 ...
- c#静态方法和非静态方法区别
c#静态方法和非静态方法区别 C#的类中可以包含两种方法:C#静态方法与非静态方法.那么他们的定义有什么不同呢?他们在使用上会有什么不同呢?让我们来看看最直观的差别:使用了static 修饰符的方法为 ...
随机推荐
- 创建线程的第二种方式------实现Runnable接口的方式
package cn.itcast.demo16.Demo07.Runnable;/** * @author newcityman * @date 2019/7/22 - 23:17 */public ...
- JVM堆空间结构及常用的jvm内存分析命令和工具
jdk8之前的运行时数据区域 程序计数器 是一块较小的内存空间,它可以看做是当前线程所执行的字节码的行号指示器.每个线程都有一个独立的程序计数器,这类内存区域为"线程私有",此内存 ...
- h5文件下载
// type1 await getFile(fileUrl).then((res) => { console.log('download',res); let bFile = window.U ...
- Android工具-DDMS
原创文章,如有转载,请注明出处:http://blog.csdn.net/yihui823/article/details/6686578 本文章的前提:已经安装了Eclipse和ADT.androi ...
- linux more 命令的基础实现。
more :分页显示文件的内容 输入 more filename 会显示文件第一屏的内容,而且会有反白的 more 提升文件的百分比.空格=下一页,q=推出,h=连接帮助 more 的用法 1. mo ...
- ICCV2021 | Tokens-to-Token ViT:在ImageNet上从零训练Vision Transformer
前言 本文介绍一种新的tokens-to-token Vision Transformer(T2T-ViT),T2T-ViT将原始ViT的参数数量和MAC减少了一半,同时在ImageNet上从 ...
- CF205A Little Elephant and Rozdil 题解
Content 有一头小象住在 \(\texttt{Rozdil}\) 小镇里,它想去其他的小镇旅行. 这个国家一共有 \(n\) 个小镇,第 \(i\) 个小镇距离 \(\texttt{Rozdil ...
- LuoguB2044 有一门课不及格的学生 题解
Content 给出一名学生的语数英三门成绩,请判断该名学生是否恰好有一门不及格(成绩小于 \(60\) 分). 数据范围:成绩在 \(0\sim 100\) 之间. Solution 强烈建议先去做 ...
- Django的安全机制 CSRF 跨站请求访问
跨站请求伪造 一.简介 django为用户实现防止跨站请求伪造的功能,通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成.而对于django中设置防 ...
- .Net Core 文件打包压缩
最近项目需要实现多文件打包的功能,尝试了一些方法,最后发现使用 ICSharpCode.SharpZipLib 最符合项目的要求. 具体实现如下: 1.在 Nuget 中安装 ICSharpCod ...