synchronized的用法及验证

最新推荐文章于 2022-08-28 12:02:51 发布
最新推荐文章于 2022-08-28 12:02:51 发布
阅读量237 收藏
点赞数
分类专栏： java基础 多线程 文章标签： synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangsweet1991/article/details/83824856
版权

synchronized有四种用法：

1、修饰普通方法与静态方法，放在范围操作符(public等)之后，返回类型声明(void等)之前。
2、对某一代码块使用，synchronized后跟括号，括号里是变量、对象、类。

修饰普通方法与静态方法，那么他们的锁分别是什么呢？让我们一起验证一下。

不加锁
public class SynWork {

	private int index;

	public void synMethod1(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				this.index = index;
				System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + this.index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	public void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				this.index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + this.index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}


public class SynTest {
	public static void main(String[] args) {
		SynWork synWork = new SynWork();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(1);
			}
		}, "T1");
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(2);
			}
		}, "T2");
		Thread thread3 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod2(30);
			}
		}, "T3");
		Thread thread4 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod2(40);
			}
		}, "T4");

		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}

}


运行结果：
synMethod1:T2:2
synMethod2:T4:40
synMethod2:T3:30
synMethod1:T1:2
synMethod2:T3:30
synMethod1:T1:1
synMethod2:T4:40
synMethod1:T2:2
synMethod1:T2:30
synMethod1:T1:30
synMethod2:T3:30
synMethod2:T4:30
枷锁后
public class SynWork {

	private int index;

	public synchronized void synMethod1(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				this.index = index;
				System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + this.index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	public synchronized void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				this.index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + this.index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}


运行结果：
synMethod1:T1:1
synMethod1:T1:1
synMethod1:T1:1
synMethod2:T4:40
synMethod2:T4:40
synMethod2:T4:40
synMethod1:T2:2
synMethod1:T2:2
synMethod1:T2:2
synMethod2:T3:30
synMethod2:T3:30
synMethod2:T3:30

继续验证

public class SynWork {
	private static int _index;

	public synchronized void synMethod1(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	public synchronized void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

public class SynTest {
	public static void main(String[] args) {
		SynWork synWork = new SynWork();
		SynWork synWork2 = new SynWork();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(1);
			}
		}, "T1");
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork2.synMethod1(2);
			}
		}, "T2");
		Thread thread3 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod2(30);
			}
		}, "T3");
		Thread thread4 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork2.synMethod2(40);
			}
		}, "T4");

		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}

}

运行结果：
synMethod1:T1:2
synMethod1:T2:2
synMethod1:T2:2
synMethod1:T1:1
synMethod1:T2:2
synMethod1:T1:2
synMethod2:T3:30
synMethod2:T4:30
synMethod2:T3:30
synMethod2:T4:40
synMethod2:T3:30
synMethod2:T4:40

由此可知修饰普通方法的锁是方法所在类的对象。

在一个类里，同时修饰普通方法和静态方法

public class SynWork {

	private static int _index;

	// 普通方法
	public synchronized void synMethod1(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	// 静态方法
	public synchronized static void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

public class SynTest {
	public static void main(String[] args) {
		SynWork synWork = new SynWork();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(1);
			}
		}, "T1");
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(2);
			}
		}, "T2");
		Thread thread3 = new Thread(new Runnable() {
			@Override
			public void run() {
				SynWork.synMethod2(30);
			}
		}, "T3");
		Thread thread4 = new Thread(new Runnable() {
			@Override
			public void run() {
				SynWork.synMethod2(40);
			}
		}, "T4");

		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}

}

运行结果：
synMethod1:T1:1
synMethod2:T3:30
synMethod2:T3:30
synMethod1:T1:30
synMethod2:T3:30
synMethod1:T1:30
synMethod1:T2:2
synMethod2:T4:40
synMethod1:T2:2
synMethod2:T4:40
synMethod2:T4:2
synMethod1:T2:2

继续验证

public class SynWork {
	private static int _index;

	// 普通方法
	public void synMethod1(int index) {
		synchronized (SynWork.class) {
			for (int i = 0; i < 3; i++) {
				try {
					_index = index;
					System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + _index);
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

	}

	// 静态方法
	public synchronized static void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}


public class SynTest {
	public static void main(String[] args) {
		SynWork synWork = new SynWork();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(1);
			}
		}, "T1");
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(2);
			}
		}, "T2");
		Thread thread3 = new Thread(new Runnable() {
			@Override
			public void run() {
				SynWork.synMethod2(30);
			}
		}, "T3");
		Thread thread4 = new Thread(new Runnable() {
			@Override
			public void run() {
				SynWork.synMethod2(40);
			}
		}, "T4");

		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}

}

运行结果：
synMethod1:T1:1
synMethod1:T1:1
synMethod1:T1:1
synMethod2:T4:40
synMethod2:T4:40
synMethod2:T4:40
synMethod1:T2:2
synMethod1:T2:2
synMethod1:T2:2
synMethod2:T3:30
synMethod2:T3:30
synMethod2:T3:30

由此可知，修饰静态方法和普通方法不是同一个锁，静态方法的锁是方法所在的类，即SynWork.class

synchronized修饰代码块

public class SynWork {
	public static int _index;

	// 普通方法
	public void synMethod1(int index) {
		synchronized (SynWork.class) {
			for (int i = 0; i < 3; i++) {
				try {
					_index = index;
					System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + _index);
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

	}

	// 静态方法
	public synchronized static void synMethod2(int index) {
		for (int i = 0; i < 3; i++) {
			try {
				_index = index;
				System.out.println("synMethod2:" + Thread.currentThread().getName() + ":" + _index);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

public class Syn2Work {

	// 普通方法
	public void synMethod1(int index) {
		synchronized (SynWork.class) {
			for (int i = 0; i < 3; i++) {
				try {
					SynWork._index = index;
					System.out.println("synMethod1:" + Thread.currentThread().getName() + ":" + SynWork._index);
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}

	}

}

public class SynTest {
	public static void main(String[] args) {
		SynWork synWork = new SynWork();
		Syn2Work syn2Work = new Syn2Work();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				synWork.synMethod1(1);
			}
		}, "T1");
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				syn2Work.synMethod1(2);
			}
		}, "T2");
		Thread thread3 = new Thread(new Runnable() {
			@Override
			public void run() {
				SynWork.synMethod2(30);
			}
		}, "T3");

		thread1.start();
		thread2.start();
		thread3.start();
	}

}

运行结果：
synMethod1:T1:1
synMethod1:T1:1
synMethod1:T1:1
synMethod2:T3:30
synMethod2:T3:30
synMethod2:T3:30
synMethod1:T2:2
synMethod1:T2:2
synMethod1:T2:2

结论：

1、synchronized修饰普通方法时，锁的是方法所在类的对象，等同于synchronized(this){}。
2、synchronized修饰static方法时，锁的是方法所在类的class，等同于synchronized(类的clas){}。
3、synchronized修饰代码块时，锁是括号里的参数，括号中的参数一致时(==)，则会形成互斥。
4、在使用synchronized时，用代码块更灵活，尽量缩小其影响范围

haodong1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
synchronized锁膨胀过程验证
weixin_39997751的博客
11-15 4868
synchronized的小故事 在并发编程中，对于synchronized和Lock的使用是很频繁的。Lock是基于Java的一个框架，synchronized是基于C语言的JVM层级的锁，使用起来很方便。 但是呢，在jdk1.6以前，synchronized是一个重量级锁，他的底层需要操作系统来支持，必然涉及到了用户态和内核态的切换，还需要挂起当前线程，知道竞争到锁才执行，因此是很耗性能的。再者，一个C语言程序性能不如Java的Lock框架，也是让人哭笑不得。 所以啊，Oracle公司决定对synchr
多线程Synchronized验证
duanlb_001的博客
03-24 418
Synchronized慎重使用
验证 synchronized 可见性
qq_25775675的博客
07-28 137
原始代码 public class Test { public static boolean flag = false; public static void main(String[] args) throws Exception { new Thread(() -> { while (true) { if (flag) { System.out.println("fla
Java synchronized锁升级过程验证
黑木爷的专栏
08-28 169
我们先介绍下锁升级过程。JD6之后分为无锁，偏向锁，轻量级锁，重量级锁。其中偏向锁->轻量级锁->重量级锁的升级过程不可逆。偏向锁：当一个线程第一次获取到锁之后，再次申请就可以直接取到锁核心思想：一开始无锁状态，JVM会默认开启“匿名”偏向的一个状态，就是一开始线程还未持有锁的时候，就预先设置一个匿名偏向锁，等一个线程持有锁之后，就会利用CAS操作将线程ID设置到对象的mark word 的高54位上【64位虚拟机】。......
synchronized验证3个理论（菜鸟玩线程）
Zohar的博客
11-08 212
synchronized验证3个理论 1.论证1 1.1理论 当多个线程同时执行synchronized(非this)同步代码块时呈同步效果。 1.2落地 1.2.1自定义锁对象类 package com.chapter02.thread2_2_8_1; public class MyObject { } 1.2.2自定义共享变量类 package com.chapter02.thread2_2...
浅谈synchronized方法对非synchronized方法的影响
08-29
1. synchronized关键字的作用是保证线程安全。 2. StringBuffer是线程安全的，因为它的方法都是synchronized的。 3. StringBuilder不是线程安全的，因为它的方法不是synchronized的。 4. synchronized方法可以保证...
[JAVA][synchronized的使用]
06-21
4. **synchronized的作用** - **防止数据不一致**：通过同步，可以避免多个线程同时修改共享数据，从而保证数据的一致性。 - **避免死锁**：虽然`synchronized`不能完全避免死锁，但它可以帮助降低发生死锁的概率...
通过volatile验证线程之间的可见性
08-25
本篇文章将深入探讨如何通过`volatile`关键字验证线程之间的可见性，并通过示例代码详细解释其工作原理。 首先，我们需要理解Java内存模型（JMM）。在JMM中，存在两种内存区域：主内存和工作内存。主内存是所有线程...
Synchronized 终极说明教程
07-19
在实际开发中，我们可以通过编写测试示例来验证`synchronized`的效果。例如，我们可以创建两个线程，一个线程负责加一操作，另一个线程负责减一操作，通过`synchronized`控制并发执行的顺序，确保结果的正确性。 五...
深析Synchronized关键字（小白慎入，深入jvm源码，两万字长文）
12-21
我们将探讨它的使用方式，特点以及如何在并发编程中发挥作用。 ### 一、Synchronized基础 1.1 **Synchronized的使用** - **实例方法**：使用`synchronized`修饰的实例方法，锁对象是调用该方法的实例。 - **静态...
synchronized方法验证,不要被谬论迷惑
sunshine716的专栏
08-01 158
       以前编程没有怎么接触过synchronized方法，不太了解，今天编程遇到了多个线程访问同一个共享资源的问题，google了下synchronized使用方法，网上有二种说法，第一种说法是当一个线程访问了某个对象中的synchronzied方法,其它线程可以继续访问其它的synchronized方法,第二个说法与第一种说法相反，不能访问。搞的我也不确定，更要命的是，这两种说法在网上一...
线程同步机制synchronized中锁的判断以及锁的作用范围
qq_40583885的博客
10-30 1623
当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。 要解决上述多线程并发访问一个资源的安全性问题，Java中提供了**同步机制(synchronized)**来解决。 为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。那么怎么去使用呢？...
温故知新-多线程-深入刨析synchronized
博客
06-01 423
Posted by 微博@Yangsc_o 原创文章，版权声明：自由转载-非商用-非衍生-保持署名 | Creative Commons BY-NC-ND 3.0 你的鼓励是我创作的最大动力
验证synchronized加在方法上，锁住的对象类别。
qq_21364629的博客
08-06 2002
最近看偶然看了别人的面经问到了synchronized的相关问题，想起了以前看过的：synchronized加在方法上，锁住的是类实例，然后还记得有个锁住的是类的.class对象。 但那时候只是看了看，记忆并不深，现在突然看到，便想着自己写一份demo去验证一下，synchronized加载方法上时，究竟锁住了写什么，验证Demo如下： public class Lock { //验证sy...
java 对方法的参数加锁_个人对synchronized锁的参数理解，如果有误望指出
weixin_32301557的博客
02-16 1808
该楼层疑似违规已被系统折叠隐藏此楼查看此楼synchronized有几种用法给方法加锁也就是在声明方法时加上synchronized关键字，这样同时就只能有一个线程访问该方法其次就是代码块，synchronized(xx){xxx}但是之前我一直不解括号里面的参数是什么..后来自己慢慢翻资料理解了一些，例如synchronized(this){xxx} this我们都知道是指当前方法的所属类而s...
synchronized(java高并发下的唯一性验证)
tianshi1017的专栏
10-24 2633
一般会遇到唯一性的问题，比如添加用户要求用户名称或登陆名唯一，我们通常的做法是：先根据条件去数据中查询是否存在，如果存在则提示已经存在了，不允许添加，否则插入。 但是这种做法在两种情况下很容易出现问题： 1. 当添加用户这个过程耗时比较长时，如果两个人同时添加了一个相同名称的用户，低并发的情况下容易两个验证都通过。比如：第一个添加还没有进入数据库，第二个已经通过了验证，准备执行添加操作时。 ...
事务的四种特性
热门推荐
东东
11-09 4万+
什么是事务: 事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败. 事务特性（4种）: 原子性 （atomicity）:强调事务的不可分割. 一致性 （consistency）:事务的执行的前后数据的完整性保持一致. 隔离性 （isolation）:一个事务执行的过程中,不应该受到其他事务的干扰 持久性（durability） :事务一旦结束,数据就持久到数据库 下面...
HTTP请求封装
东东
06-25 5320
目前JAVA实现HTTP请求的方法用的最多的有两种： 1、通过HttpURLConnection去实现，HttpURLConnection是JAVA的标准类，是JAVA比较原生的一种实现方式。 2、通过HTTPClient这种第三方的开源框架去实现。应用最广泛的就是apache的HTTPClient，有两大版本，HttpClient3.1 是 org.apache.commons.httpcl...
synchronized用法（）
最新发布
09-14
synchronized用法是为了实现多线程程序中的同步操作，确保多个线程在访问共享资源时的安全性。在Java中，可以使用synchronized关键字来标记方法或代码块，并确保同一时间只有一个线程可以执行被标记的部分。 在给出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值