Java Synchronized关键字学习记录1：用法

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量127 收藏
点赞数
分类专栏： Java底层理解 Gitee迁移 文章标签： java 锁 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Genmer/article/details/119654079
版权

【声明】：本篇文章来自本人gitee仓库搬运至CSDN，https://gitee.com/genmers/md-notes

文章目录

引言

在开始记录之前，我来说说为什么需要学习这个关键字，以下是百度百科关于线程安全的一段描述

如果一个函数能够安全地同时被多个线程调用而得到正确的结果，那么，我们说这个函数是线程安全的。++所谓“安全”，一切可能导致结果不正确的因素都是不安全的调用。++
线程安全，是针对多线程而言的。与可重入联系起来，我们可以断定：可重入函数必定是线程安全的，但线程安全的不一定是可重入的。不可重入函数，函数调用结果不具有可再现性，可以通过互斥锁等机制使之能安全地同时被多个线程调用，那么，这个不可重入函数就是转换成了线程安全。

从第一句话我们就可以看出，线程安全无非就是要保证程序或者软件能在高负载的情况下依然不会出错

众所周知，同一进程的不同线程会共享同一主内存，而多个线程同时对共享内存读写时，若要保证线程安全，则必须通过加锁的方式。

Java中有两个主要的线程安全相关的关键字Synchronied和Volatile，今天我们来一起学习下Synchronied

一、Synchronized的两个用法

一句话说出Synchronized的作用

能够保证在同一时刻最多只有一个线程执行该段代码，以达到并发的安全效果。

对象锁

包括方法锁（默认锁对象为this即当前实例对象）和同步代码块（自己指定锁对象）

类锁

指syncronized修饰静态方法或者指定锁为Class对象。

在开始之前，我们先用一个例子来看看没有控制并发会有什么后果

栗子0:不控制并发的后果

package synchronizedknowedge;

/**
 * 不开启线程同步的后果
 */
public class DisappearRequest1 implements Runnable{
	static DisappearRequest1 instance = new DisappearRequest1();

	static int i =0;

	public static void main(String[] args) throws InterruptedException {
		Thread t1 =new Thread(instance);
		Thread t2 =new Thread(instance);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(i);
	}
	@Override
	public void run() {
		for (int j=0;j<10000;j++){
			i++;
		}
	}
}


14178

按照我们执行一次10000来说，两个线程应该20000，得到的结果永远低于20000，不控制线程会引发一系列的并发问题

第一个用法：对象锁
  • 代码块形式：锁的括号里的对象，对给定对象加锁，进入同步代码库前需要获得给定对象的锁
  • 方法锁形式：synchronized修饰普通方法，锁对象默认为this

栗子1 : 同步代码块

package synchronizedknowedge;

/**
 * 对象锁示例1 - 同步代码块
 */
public class SynchronizedObjectCodeBlock implements Runnable{
	static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();

	@Override
	public void run() {
		synchronized (this) {
			System.out.println("我是对象锁的代码块形式，我是"+Thread.currentThread().getName());
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"结束了");
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Thread t1 =new Thread(instance);
		Thread t2 =new Thread(instance);
		t1.start();
		t2.start();
		while (t1.isAlive() || t2.isAlive()){
			Thread.sleep(3000);
		}
		System.out.println("finished");
	}
}

运行结果

我是对象锁的代码块形式，我是Thread-0
//sleep3000ms
Thread-0结束了
我是对象锁的代码块形式，我是Thread-1
//sleep3000ms
Thread-1结束了
finished

而如果注释掉Synchronied，结果就会是

我是对象锁的代码块形式，我是Thread-0
我是对象锁的代码块形式，我是Thread-1
//sleep3000ms
Thread-1结束了
Thread-0结束了
finished

简单来说以上的情况就是，两个线程Thread-0，Thread-1都想执行同步代码块里的代码，但因为有Synchronied存在，一次只能一个对象获得锁（执行权）

而情况如果复杂点，就用自己定义的锁对象

栗子2:自定义锁对象

Object lock1 = new Object();
Object lock2 = new Object();

	@Override
	public void run() {
		synchronized (lock1) {
			System.out.println(Thread.currentThread().getName()+"拿到了lock1");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"的lock1结束了");
		}

		synchronized (lock2) {
			System.out.println(Thread.currentThread().getName()+"拿到了lock2");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"的lock2结束了");
		}
	}


Thread-0拿到了lock1
//sleep3000ms
Thread-0的lock1结束了
Thread-0拿到了lock2
Thread-1拿到了lock1
//sleep3000ms
Thread-1的lock1结束了
Thread-0的lock2结束了
Thread-1拿到了lock2
//sleep3000ms
Thread-1的lock2结束了
finished

机制相同，不一样的是同步代码库变成两个，两个线程想去执行这两个代码就要先获取那个代码块的锁，同一时间同一代码块只有一个线程能拿到锁（执行权）

栗子3:普通方法锁

package synchronizedknowedge;

/**
 * 对象锁的第二种形式 - 普通方法锁
 */
public class SynchroniedObjectMethod3 implements Runnable {
	static SynchroniedObjectMethod3 instance = new SynchroniedObjectMethod3();

	public static void main(String[] args) throws InterruptedException {
		Thread t1 =new Thread(instance);
		Thread t2 =new Thread(instance);
		t1.start();
		t2.start();
		while (t1.isAlive() || t2.isAlive()){
			Thread.sleep(3000);
		}
		System.out.println("finished");
	}

	@Override
	public void run() {
		method();
	}

	public synchronized void method(){
		System.out.println("我是对象锁的方法修饰符方式"+Thread.currentThread().getName());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"运行结束");
	}
}


我是对象锁的方法修饰符方式Thread-0
//sleep3000ms
Thread-0运行结束
我是对象锁的方法修饰符方式Thread-1
//sleep3000ms
Thread-1运行结束
finished
第二个用法：类锁

概念：Java类可能会有多个对象，但只有一个Class对象

类锁 = Class对象的锁

那类锁和对象锁的区别就是

对象的实例可以有很多个，而Class对象只有一个

就是说，对象锁说把同步（串形执行）的范围限定在制定的对象锁上，而如果对象锁有多个，理论上多个不同的对象锁还是可以同步执行同一个代码块

而类只有一个，就会在这个类的范围里同步

类锁的两种形式

形式1:synchronized加在static方法上
注意static无法直接重写在run方法上，因为不够

栗子4：在synchronied修饰的方法前加static

package synchronizedknowedge;

/**
 * 类锁的第一种形式：static形式 static加在方法上
 */
public class SynchronizedClassStatic4 implements Runnable {
	static SynchronizedClassStatic4 instance1 = new SynchronizedClassStatic4();
	static SynchronizedClassStatic4 instance2 = new SynchronizedClassStatic4();

	@Override
	public void run() {
		method();
	}
	public synchronized void method(){
		System.out.println("我是类锁的第一种方法：static形式，我是"+ Thread.currentThread().getName());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"运行结束");
	}

	public static void main(String[] args) {
		Thread t1 = new Thread(instance1);
		Thread t2 = new Thread(instance2);
		t1.start();
		t2.start();
		while (t1.isAlive() || t2.isAlive()) {
		}
		System.out.println("finished");
	}
}

无static修饰method，就会两个实例同时执行

我是类锁的第一种方法：static形式，我是Thread-0
我是类锁的第一种方法：static形式，我是Thread-1
//sleep3000ms
Thread-0运行结束
Thread-1运行结束
finished

如上可见，跟之前不同的是，对象的实例有两个，正常情况下因为是两个不同的实例即使用了同步代码块也没用

public  synchronized void method(){
		synchronized (this){
			System.out.println("我是类锁的第一种方法：static形式，我是"+ Thread.currentThread().getName());
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"运行结束");
		}
	}

结果也没发生改变，这时候要实现串形执行就要在方法上加入static

public static synchronized void method(){
		System.out.println("我是类锁的第一种方法：static形式，我是"+ Thread.currentThread().getName());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"运行结束");
	}

我是类锁的第一种方法：static形式，我是Thread-0
//sleep3000ms
Thread-0运行结束
我是类锁的第一种方法：static形式，我是Thread-1
//sleep3000ms
Thread-1运行结束
finished

形式2：synchronied（*.class）代码块

package synchronizedknowedge;

/**
 * 类锁的第二种形式 synchronied(*.class)
 */
public class SynchroniedClassClass5 implements Runnable {
	static SynchroniedClassClass5 instance1 = new SynchroniedClassClass5();
	static SynchroniedClassClass5 instance2 = new SynchroniedClassClass5();

	public static void main(String[] args) {
		Thread t1 = new Thread(instance1);
		Thread t2 = new Thread(instance2);
		t1.start();
		t2.start();
		while (t1.isAlive() || t2.isAlive()) {
		}
		System.out.println("finished");
	}

	@Override
	public void run() {
		method();
	}

	private void method(){
		synchronized (SynchroniedClassClass5.class){
			System.out.println("我是类锁的第二种方法：synchronied(*.class)形式，我是"+ Thread.currentThread().getName());
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"运行结束");
		}
	}
}


我是类锁的第二种方法：synchronied(*.class)形式，我是Thread-0
//sleep3000ms
Thread-0运行结束
我是类锁的第二种方法：synchronied(*.class)形式，我是Thread-1
//sleep3000ms
Thread-1运行结束
finished

既然学完这几种方式，那我们用它来解决一下栗子0的问题

	@Override
	public synchronized void run() {
		for (int j=0;j<10000;j++){
			i++;
		}
	}

@Override
	public void run() {
		synchronized (this) {
			for (int j=0;j<10000;j++){
				i++;
			}
		}
	}

@Override
	public void run() {
		synchronized (DisappearRequest1.class) {
			for (int j=0;j<10000;j++){
				i++;
			}
		}
	}

以上几种方法都能解决栗子0的问题，由于run是实现Runnable接口的方法，我们不能擅自修改（增加static）

20000

二、参考资料

Java Synchronized关键字学习记录2：性质和原理

Genmer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized锁run()的问题
qq_41120971的博客
06-03 1068
在一个模拟银行取钱的例子上，直接把synchronized加到了run方法上，发现并没有解决并发带来的不安全性。 class GetMoney extends Thread{ private Account account; private Integer needMoney; public GetMoney(Account account, Integer needMoney) { this.account = account; this.need
java中线程同步（synchronized的用法）
01-16 492
多线程存在的问题 1.多线程会造成共享资源数据环混乱。因为，每一个线程都有自己的内存。当一个线程从公共资源读取数据后，保存到了自己线程的内存中，然后才执行。这样如果多个线程同时读取公共资源的数据，而没有手段去控制让这些线程排队，就会出现数据混乱的问题。 下面的代码为例子：是一个抢票的例子 package Lock; //线程不安全实例1：共用对象 public class UnSaveTest1 implements Runnable{ private int ticketNum=10; public
java synchronized关键字的用法
果酱 の 博客
07-24 2940
在Java中，多线程编程是一项常见的任务。为了保证多线程程序的正确性和一致性，我们需要使用同步机制来控制线程的访问。synchronized关键字是Java中最基本的同步机制之一，它可以用于修饰方法或代码块，实现线程的互斥访问和共享数据的同步操作。本文将详细介绍synchronized关键字的用法，以及它在多线程编程中的应用。
Java中Synchronized关键字的基本使用方法
zh123456_789的博客
02-15 781
java中Synchronized关键字的基本使用
java synchronized关键字_Java：手把手教你全面学习神秘的Synchronized关键字
weixin_28908491的博客
03-04 75
前言在Java中，有一个常被忽略 但 非常重要的关键字Synchronized今天，我将详细讲解 Java关键字Synchronized的所有知识，希望你们会喜欢目录示意图1. 定义Java中的1个关键字2. 作用保证同一时刻最多只有1个线程执行 被Synchronized修饰的方法 / 代码其他线程 必须等待当前线程执行完该方法 / 代码块后才能执行该方法 / 代码块3. 应用场景保证线程安全，...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 172
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 491
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1139
JVM-垃圾回收与内存分配
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1168
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1065
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 513
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 547
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
每 日练 习
m0_67187271的博客
07-19 1023
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 483
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 230
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
码农生涯问题杂记
qq_38189542的博客
07-18 168
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 947
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
达梦数据库 CASE_SENSITIVE参数的理解
qq_44669390的博客
07-19 888
CASE_SENSITIVE
java的基本参数类型和引用参数类型在传递的时候是否会影响实际参数呢?
Lele0456789的博客
07-19 145
/基本数据类型在传递真实的参数时,传递的是真实的数据,形参的改变,不影响实际参数的值。System.out.println("调用change方法前"+number);System.out.println("调用change方法后"+number);//传递引用数据类型的时候,传递的是地址值,形参的改变,影响实际参数的值。
"Java多线程与并发：synchronized关键字详解及应用
通过本文的学习，读者将更深入地理解Synchronized关键字在Java多线程编程中的重要性，以及如何更加高效地利用它来实现线程安全和同步。 在学习中，读者可以带着一些BAT大厂的面试问题，这将有助于更好地理解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值