多线程中如何解决资源争抢的问题(synchronized关键字)？

最新推荐文章于 2024-08-25 11:24:51 发布
最新推荐文章于 2024-08-25 11:24:51 发布
阅读量2.9k 收藏 5
点赞数
分类专栏： 多线程并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39309402/article/details/106358355
版权

说到解决多线程中资源争抢的问题，大多数第一个想到的关键字就是synchronized，它能够保证多个线程之间资源访问的同步性（即它修饰的方法或者代码块在任意时刻只能有一个线程执行）。

/**
 * 一个座位一个人 两个电影窗口卖票 不加锁会造成什么结果？
 */
public class Seat implements Runnable {
	private int seatNumber = 100;

	@Override
	public void run() {
		while (true) {
			if (seatNumber > 0) {
				try {
					Thread.sleep(30);
					--seatNumber;
					System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + seatNumber + "个座位");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！");
				break;
			}
		}
	}

	public static void main(String[] args) {
		Seat mr = new Seat();
		Thread t1 = new Thread(mr, "A窗口");
		Thread t2 = new Thread(mr, "B窗口");
		t1.start();
		t2.start();
	}
}

可以明显看出，不加synchronized，无法解决资源争抢的问题，我们可以这样改下代码：

@Override
	public void run() {
		while (true) {
			synchronized (this) {
				if (seatNumber > 0) {
					try {
						Thread.sleep(30);
						--seatNumber;
						System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + seatNumber + "个座位");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else {
					System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！");
					break;
				}
			}
		}
	}

加了synchronized，这个问题就解决了。需要知道的是，早期（Jdk1.6以前）synchronized属于重量级锁，效率低下，而在Java6之后，Java官方从JVM层面对synchronized进行了大的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

那么，如何使用synchronized关键字呢？
1）修饰实例方法：作用于当前对象实例，即锁对象即为当前对象。

/**
 * synchronized修饰实例方法
 */
public class ExampleTest implements Runnable {
	private int seatNumber = 100;

	@Override
	public void run() {
		while (true) {

			if (save()) {
				try {
					Thread.sleep(30);
					--seatNumber;
					System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + seatNumber + "个座位");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！");
				break;
			}

		}
	}

	private synchronized boolean save() {
		if (seatNumber > 0) {
			return true;
		} else {
			return false;
		}
	}

	public static void main(String[] args) {
		ExampleTest mr = new ExampleTest();
		Thread t1 = new Thread(mr, "A窗口");
		Thread t2 = new Thread(mr, "B窗口");
		t1.start();
		t2.start();
	}
}
执行结果：
A窗口占用1个座位，还剩余 99个座位
B窗口占用1个座位，还剩余 99个座位
B窗口占用1个座位，还剩余 98个座位
A窗口占用1个座位，还剩余 97个座位
A窗口占用1个座位，还剩余 95个座位
B窗口占用1个座位，还剩余 95个座位
A窗口占用1个座位，还剩余 93个座位
B窗口占用1个座位，还剩余 93个座位
A窗口占用1个座位，还剩余 91个座位
B窗口占用1个座位，还剩余 91个座位
B窗口占用1个座位，还剩余 90个座位
A窗口占用1个座位，还剩余 90个座位
A窗口占用1个座位，还剩余 88个座位
B窗口占用1个座位，还剩余 88个座位
B窗口占用1个座位，还剩余 87个座位
A窗口占用1个座位，还剩余 86个座位
B窗口占用1个座位，还剩余 84个座位
A窗口占用1个座位，还剩余 84个座位
B窗口占用1个座位，还剩余 83个座位
A窗口占用1个座位，还剩余 82个座位
B窗口占用1个座位，还剩余 81个座位
A窗口占用1个座位，还剩余 80个座位
B窗口占用1个座位，还剩余 79个座位
A窗口占用1个座位，还剩余 78个座位
B窗口占用1个座位，还剩余 76个座位
A窗口占用1个座位，还剩余 76个座位
B窗口占用1个座位，还剩余 75个座位
A窗口占用1个座位，还剩余 74个座位
A窗口占用1个座位，还剩余 73个座位
B窗口占用1个座位，还剩余 72个座位
B窗口占用1个座位，还剩余 70个座位
A窗口占用1个座位，还剩余 70个座位
B窗口占用1个座位，还剩余 69个座位
A窗口占用1个座位，还剩余 68个座位
B窗口占用1个座位，还剩余 66个座位
A窗口占用1个座位，还剩余 66个座位
B窗口占用1个座位，还剩余 65个座位
A窗口占用1个座位，还剩余 64个座位
A窗口占用1个座位，还剩余 63个座位
B窗口占用1个座位，还剩余 62个座位
A窗口占用1个座位，还剩余 60个座位
B窗口占用1个座位，还剩余 60个座位
B窗口占用1个座位，还剩余 59个座位
A窗口占用1个座位，还剩余 58个座位
B窗口占用1个座位，还剩余 57个座位
A窗口占用1个座位，还剩余 56个座位
B窗口占用1个座位，还剩余 55个座位
A窗口占用1个座位，还剩余 54个座位
B窗口占用1个座位，还剩余 53个座位
A窗口占用1个座位，还剩余 52个座位
B窗口占用1个座位，还剩余 51个座位
A窗口占用1个座位，还剩余 50个座位
A窗口占用1个座位，还剩余 49个座位
B窗口占用1个座位，还剩余 48个座位
B窗口占用1个座位，还剩余 47个座位
A窗口占用1个座位，还剩余 47个座位
B窗口占用1个座位，还剩余 46个座位
A窗口占用1个座位，还剩余 45个座位
A窗口占用1个座位，还剩余 44个座位
B窗口占用1个座位，还剩余 43个座位
A窗口占用1个座位，还剩余 42个座位
B窗口占用1个座位，还剩余 42个座位
A窗口占用1个座位，还剩余 41个座位
B窗口占用1个座位，还剩余 40个座位
A窗口占用1个座位，还剩余 38个座位
B窗口占用1个座位，还剩余 38个座位
A窗口占用1个座位，还剩余 37个座位
B窗口占用1个座位，还剩余 36个座位
A窗口占用1个座位，还剩余 35个座位
B窗口占用1个座位，还剩余 34个座位
A窗口占用1个座位，还剩余 33个座位
B窗口占用1个座位，还剩余 32个座位
A窗口占用1个座位，还剩余 31个座位
B窗口占用1个座位，还剩余 30个座位
A窗口占用1个座位，还剩余 29个座位
B窗口占用1个座位，还剩余 28个座位
A窗口占用1个座位，还剩余 27个座位
B窗口占用1个座位，还剩余 26个座位
A窗口占用1个座位，还剩余 25个座位
B窗口占用1个座位，还剩余 24个座位
A窗口占用1个座位，还剩余 23个座位
B窗口占用1个座位，还剩余 22个座位
A窗口占用1个座位，还剩余 21个座位
B窗口占用1个座位，还剩余 20个座位
A窗口占用1个座位，还剩余 19个座位
B窗口占用1个座位，还剩余 18个座位
A窗口占用1个座位，还剩余 17个座位
B窗口占用1个座位，还剩余 16个座位
A窗口占用1个座位，还剩余 15个座位
B窗口占用1个座位，还剩余 14个座位
A窗口占用1个座位，还剩余 13个座位
B窗口占用1个座位，还剩余 12个座位
A窗口占用1个座位，还剩余 11个座位
B窗口占用1个座位，还剩余 10个座位
A窗口占用1个座位，还剩余 9个座位
B窗口占用1个座位，还剩余 8个座位
A窗口占用1个座位，还剩余 7个座位
B窗口占用1个座位，还剩余 6个座位
A窗口占用1个座位，还剩余 5个座位
B窗口占用1个座位，还剩余 4个座位
A窗口占用1个座位，还剩余 3个座位
B窗口占用1个座位，还剩余 2个座位
A窗口占用1个座位，还剩余 1个座位
B窗口占用1个座位，还剩余 0个座位
B窗口:不好意思，票卖完了！
A窗口占用1个座位，还剩余 -1个座位
A窗口:不好意思，票卖完了！

2）修饰静态方法：作用的范围是整个静态方法，作用的对象是这个类的所有对象，因为静态成员不属于任何一个实例对象，是类成员（static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。

所以如果一个线程A调用一个实例对象的非静态synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized方法占用的锁是当前类的锁，而访问非静态synchronized 方法占用的锁是当前实例对象锁。

/**
 * synchronized修饰静态方法
 */
public class StaticTest implements Runnable {

	private static int seatNumber = 100;

	@Override
	public void run() {
		while (true) {
			if (save()) {
				try {
					Thread.sleep(30);
					--seatNumber;
					System.out.println(Thread.currentThread().getName() + "占用1个座位，还剩余 " + seatNumber + "个座位");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + ":不好意思，票卖完了！");
				break;
			}
		}
	}

	private synchronized static boolean save() {
		if (seatNumber > 0) {
			return true;
		} else {
			return false;
		}
	}

	public static void main(String[] args) {
		StaticTest mr = new StaticTest();
		Thread t1 = new Thread(mr, "A窗口");
		Thread t2 = new Thread(mr, "B窗口");
		t1.start();
		t2.start();
	}
}
A窗口占用1个座位，还剩余 98个座位
B窗口占用1个座位，还剩余 98个座位
A窗口占用1个座位，还剩余 97个座位
B窗口占用1个座位，还剩余 96个座位
A窗口占用1个座位，还剩余 95个座位
B窗口占用1个座位，还剩余 94个座位
B窗口占用1个座位，还剩余 93个座位
A窗口占用1个座位，还剩余 92个座位
B窗口占用1个座位，还剩余 91个座位
A窗口占用1个座位，还剩余 90个座位
B窗口占用1个座位，还剩余 89个座位
A窗口占用1个座位，还剩余 88个座位
B窗口占用1个座位，还剩余 87个座位
A窗口占用1个座位，还剩余 86个座位
B窗口占用1个座位，还剩余 85个座位
A窗口占用1个座位，还剩余 84个座位
B窗口占用1个座位，还剩余 83个座位
A窗口占用1个座位，还剩余 82个座位
B窗口占用1个座位，还剩余 81个座位
A窗口占用1个座位，还剩余 80个座位
B窗口占用1个座位，还剩余 79个座位
A窗口占用1个座位，还剩余 78个座位
B窗口占用1个座位，还剩余 77个座位
A窗口占用1个座位，还剩余 76个座位
B窗口占用1个座位，还剩余 75个座位
A窗口占用1个座位，还剩余 74个座位
B窗口占用1个座位，还剩余 73个座位
A窗口占用1个座位，还剩余 72个座位
B窗口占用1个座位，还剩余 71个座位
A窗口占用1个座位，还剩余 70个座位
B窗口占用1个座位，还剩余 69个座位
A窗口占用1个座位，还剩余 68个座位
B窗口占用1个座位，还剩余 67个座位
A窗口占用1个座位，还剩余 66个座位
B窗口占用1个座位，还剩余 65个座位
A窗口占用1个座位，还剩余 64个座位
B窗口占用1个座位，还剩余 63个座位
A窗口占用1个座位，还剩余 62个座位
B窗口占用1个座位，还剩余 61个座位
A窗口占用1个座位，还剩余 60个座位
B窗口占用1个座位，还剩余 59个座位
A窗口占用1个座位，还剩余 58个座位
B窗口占用1个座位，还剩余 57个座位
A窗口占用1个座位，还剩余 56个座位
B窗口占用1个座位，还剩余 55个座位
A窗口占用1个座位，还剩余 54个座位
B窗口占用1个座位，还剩余 53个座位
A窗口占用1个座位，还剩余 52个座位
B窗口占用1个座位，还剩余 51个座位
A窗口占用1个座位，还剩余 50个座位
B窗口占用1个座位，还剩余 49个座位
A窗口占用1个座位，还剩余 48个座位
B窗口占用1个座位，还剩余 47个座位
A窗口占用1个座位，还剩余 46个座位
B窗口占用1个座位，还剩余 45个座位
A窗口占用1个座位，还剩余 44个座位
B窗口占用1个座位，还剩余 43个座位
A窗口占用1个座位，还剩余 42个座位
B窗口占用1个座位，还剩余 41个座位
A窗口占用1个座位，还剩余 40个座位
B窗口占用1个座位，还剩余 39个座位
A窗口占用1个座位，还剩余 38个座位
B窗口占用1个座位，还剩余 37个座位
A窗口占用1个座位，还剩余 36个座位
B窗口占用1个座位，还剩余 35个座位
A窗口占用1个座位，还剩余 34个座位
B窗口占用1个座位，还剩余 33个座位
A窗口占用1个座位，还剩余 32个座位
B窗口占用1个座位，还剩余 31个座位
A窗口占用1个座位，还剩余 30个座位
B窗口占用1个座位，还剩余 29个座位
A窗口占用1个座位，还剩余 28个座位
B窗口占用1个座位，还剩余 27个座位
A窗口占用1个座位，还剩余 26个座位
B窗口占用1个座位，还剩余 25个座位
A窗口占用1个座位，还剩余 24个座位
B窗口占用1个座位，还剩余 23个座位
A窗口占用1个座位，还剩余 22个座位
B窗口占用1个座位，还剩余 21个座位
A窗口占用1个座位，还剩余 20个座位
B窗口占用1个座位，还剩余 19个座位
A窗口占用1个座位，还剩余 18个座位
B窗口占用1个座位，还剩余 17个座位
A窗口占用1个座位，还剩余 16个座位
B窗口占用1个座位，还剩余 15个座位
A窗口占用1个座位，还剩余 14个座位
B窗口占用1个座位，还剩余 13个座位
A窗口占用1个座位，还剩余 12个座位
B窗口占用1个座位，还剩余 11个座位
A窗口占用1个座位，还剩余 10个座位
B窗口占用1个座位，还剩余 9个座位
A窗口占用1个座位，还剩余 8个座位
B窗口占用1个座位，还剩余 7个座位
A窗口占用1个座位，还剩余 6个座位
B窗口占用1个座位，还剩余 5个座位
A窗口占用1个座位，还剩余 4个座位
B窗口占用1个座位，还剩余 3个座位
A窗口占用1个座位，还剩余 2个座位
B窗口占用1个座位，还剩余 1个座位
A窗口占用1个座位，还剩余 0个座位
A窗口:不好意思，票卖完了！
B窗口占用1个座位，还剩余 -1个座位
B窗口:不好意思，票卖完了！

3）修饰代码块：指定加锁对象，对给定对象加锁，即锁对象即为小括号中的对象。

>>>>>总结<<<<<

synchronized关键字的作用就是为了保证同一时刻只能有1个线程执行Synchronized修饰的方法和代码块，需要注意的是，实际同步的是对象或者类，而非代码。所以，此时此刻，其他线程必须等待当前线程执行完毕才可以继续执行。所以，synchronized（解决的多线程并发其实是阻塞型并发）一般用在以下场景：

1）修饰实例方法 / 代码块时，（同步）保护的是同一个对象方法的调用 & 当前实例对象


2）修饰静态方法 / 代码块时，（同步）保护的是 静态方法的调用 & class 类对象

南丘xf
关注
专栏目录
Java多线程核心技术-volatile和sychronizd关键字
weixin_51438023的博客
08-19 299
synchronized synchronized关键字可以保障原子性，可见性和有序性 线程不安全 非线程安全问题会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是”脏读“，什么是脏读呢？mysql事务中的脏读和这个很类似，读取到的数据是被更改过的。 线程安全是指获得实例变量的值是经过同步处理的，不会出现脏读 public class safe { public void add(String username){ int num = 0;//方法内 }
解决多线程对资源争夺问题：进程互斥方法---Event
m0_51489557的博客
03-25 357
解决多线程之间资源争夺问题方法，使用Event这种进程互斥犯法
C++ | 多线程资源抢占bug解决
RandyOliver's House
06-29 415
就像球场上，大家都在争夺1个球，都想控球，完成自己的任务，这就是资源抢占。避免多线程同时访问公共变量，读取可以，如果写入，必须明确写入的位置，如果容器是动态分配的，事先也不知道要向公共容器里写入多少数据，可以为每个线程分配单独的容器，最后再合并。为每个线程配备一个数组，每个线程将global_id写入自己的数组，线程结束后，再对各个线程的global_id 数组进行合并。，因为是无符号的，所以 0 - 1 得到一个很大的值，造成了通过randy_id再取值的时候数组越界。这里线程开启前，声明了1个。
多线程 --- 竞争与互斥
最新发布
BUG制造机的博客
08-25 715
在这篇文章中，我们介绍了多线程竞争以及解决的其中一个方案 — 互斥锁，还讲解了互斥锁的实现原理，希望大家有所收获！
Semphore-多线程争抢多资源解决方案
雪落南城的博客
02-18 658
当我们遇到N个线程抢夺M个资源时（N>M）,可以使用Semphore 我们模拟 6辆车抢3个车位 代码： public static void main(String[] args) { //模拟6辆车抢3个车位 Semaphore semaphore = new Semaphore(3); for (int i = 1; i <=6 ...
多线程学习 遇到问题（二） 资源抢夺
weixin_43085185的博客
02-22 700
解决多线程资源争夺的方法很多，队列是最好的方法之一，下面的例子很好的演示了队列在多线程中的应用，使用的生产者消费者模型，有时间写成面向对象的方式。 互斥锁等也可以解决此类情况，但效率没有队列高。 import requests from lxml import etree from urllib import request from queue import Queue import threa...
多线程下解决资源竞争的7种方法
w36680130的博客
12-15 590
多线程下解决资源竞争的7种方法
Java多线程、并发时使用Synchronized（同步锁）解决资源竞争问题
11-14 1328
业务场景：地图绘制时将绘制好的地图信息（如坐标、关联任务信息等等）保存到DB同时在Redis中保存一份缓存数 据。 问题描述：前端页面显示时发现有重复数据，如：同一个地图信息展示了两次。 解决思路：先是断点检查了一下代码，发现程序正常执行，检查DB物理数据库发现数据正常，检查Redis缓存数据发 现将DB中的数据在Redis中存了两次。（DB中共144条数 据，Redis中288条数据）。
多线程（synchronized）的问题
zhangxihe的博客
11-29 141
[size=medium]1.在静态方法上使用同步时会发生什么事？ 同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。 2.静态同步方法与非静态同步方法会相互影响吗？ 静态方法的锁对象是该类的“Class”对象，非静态方法...
多线程知识之synchronized
qq_37962402的博客
12-27 293
知识点 方法中的变量都是线程安全的,不会被外部变量改变值. 只有共享的资源才需要同步化,如果不是共享的,没有必要同步 如果锁同一个对象,则只有等一个方法释放锁之后,才会执行下一个方法. 例如:String str=new String(); String str = new String(); synchronized public void methon1 (str){ } synchronized public void methon2 (str){ } 如果在执行metho.
多线程：synchronized
五山口老法师
01-10 119
https://blog.csdn.net/javazejian/article/details/72828483#中断与synchronized
多线程独占资源的处理
woshizfs(软件开发)的专栏
04-30 2295
#include #include using namespace std; HANDLE hMutex; DWORD WINAPI fun(LPVOID ip){ while (1) { WaitForSingleObject(hMutex,INFINITE); cout Sleep(1000); ReleaseMutex(hMutex); } } int main
Java多线程资源竞争处理策略：实用技巧和最佳实践
KKKL518的博客
06-16 1139
单一继承：抽象类只能继承自另一个抽象类或非抽象类，不能实现多个接口。构造函数：抽象类可以包含构造函数，子类必须显式调用父类的构造函数。实例变量：抽象类可以包含实例变量，子类必须提供这些变量的实现。抽象方法：抽象类可以包含抽象方法，子类必须实现这些方法。
多线程同步时如何优化锁抢占
weixin_35749545的博客
12-20 350
在多线程环境中，如果要对共享资源进行同步访问，就必须使用锁机制。但是，锁的使用会带来一些性能问题，尤其是在竞争激烈的情况下。因此，有必要对锁的使用进行优化。 具体来说，有以下几种方法可以优化锁的抢占： 尽量减少锁的使用：可以尽量减少锁的使用，只在必要的时候才使用。例如，可以使用原子操作来代替锁。 使用较小的锁：如果只有少数的共享资源需要同步，就可以使用较小的锁，例如局部变量锁或者线程本地存储。...
多线程操作一个资源时，互相争抢的案例
weixin_45144254的博客
04-03 428
java 多线程资源争抢 火车票案例
多线程常见面试题（含常见项目遇到多线程问题解决及面试对话）
喜欢吃糖丶的博客
07-30 7891
纯面试 纯文字 看起来乱但适合面试总结 多线程 什么是线程和进程?他们是什么关系？ 进程：在操作系统中能够独立运行，并且作为资源分配的基本单位。它表示运行中的程序。系统运行一个程序就是一个进程从创建、运行到消亡的过程。 线程：是一个比进程更小的执行单位，能够完成进程中的一个功能，也被称为轻量级进程。一个进程在其执行的过程中可以产生多个线程。 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行 进程要想执行任务，必须得有线程，进程至少要有一条线程 多线程有什么用？ 发挥多核CPU的优势 防止.
多线程–Synchronized
12-21
1.为什么要使用synchronized 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。 案例 package com.yxl.demo.ThreadTest; public class test5 { public static void main(String[] args) { TestDemo thread = new TestDemo(
资源抢夺 多线程
weixin_30515513的博客
03-29 336
#import "ViewController.h" @interface ViewController () @property (weak, nonatomic) IBOutlet UITextView *infoText; /** 在iOS中还有一种锁的功能，原子锁 —— 多读单写的锁（128位自旋锁），也会消耗性能 原子锁只保护写入时的数据正确，而读取...
解决多线程中资源竞争
zz_zss的博客
10-04 1849
并行：多个CPU同时执行多个任务，就好像有两个程序，这两个程序是真的在两个不同的CPU内同时被执行。 并发：CPU交替处理多个任务，还是有两个程序，但是只有一个CPU，会交替处理这两个程序，而不是同时 执行，只不过因为CPU执行的速度过快，而会使得人们感到是在“同时”执行，执行的先后取决于各个程序 对于时间片资源的争夺。 在多线程中利用互斥锁解决资源竞争 多线程共享全局变量 进程线程区别（把进程理解为流水线 线程就是流水线上的工人） 进程是资源分配的单位 线程是操作系统调度的单位 线程不能独立运行 需依
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值