synchronized:同步锁

最新推荐文章于 2022-03-15 10:54:48 发布
最新推荐文章于 2022-03-15 10:54:48 发布
阅读量231 收藏
点赞数
分类专栏： 笔记 案例 文章标签： synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Logan_addoil/article/details/96891600
版权

文章目录

synchronized

synchronized关键字:同步, 反义词 asynchronized 异步
同步资源,同步锁

  • 此关键字可以修饰在方法上
    比如:
    public synchronized void method(){
    //代码块
    }
    当线程1调用method方法时,就会给method方法添加一个锁
    如果方法不执行完毕,其他线程就不会执行此代方法,线程排队等待

  • 此关键字修饰在对象上
    比如:
    synchronized(某个对象){
    //同步代码块
    }
    当线程1执行同步代码块时,就会给同步代码块添加一个锁
    如果代码块不执行完毕,其他线程就不会执行此代码块,线程排队等待

  • 此关键字修饰在类上
    比如 :
    synchronized (类名.class){
    //同步代码块

    }
    当线程1执行同步代码块时,就会给类添加一个锁
    如果代码块不执行完毕,其他线程就不会执行此代码块,线程排队等待

    下面来具体介绍

synchronized同步方法测试

案例一

synchronized作用在同一个实例对象(test)上,
两个线程,一个线程调用synchronized修饰的方法,另一个调用普通的方法

public class SynchronizedTest1 {
   public synchronized void methodA(){
   	try{
   		for(int i=0;i<5;i++){
   			System.out.println("methodA="+i);
   			Thread.sleep(1000);
   		}			
   	}catch (Exception e){
   		e.printStackTrace();
   	}
   }
   public void methodB(){
   	try{
   		for(int i=0;i<5;i++){
   			System.out.println("methodB="+i);
   			Thread.sleep(1000);
   		}
   		
   	}catch (Exception e){
   		e.printStackTrace();
   	}
   }
   public static void main(String[] args) {
   	SynchronizedTest1 test =new SynchronizedTest1();
   	
   	Thread t1 =new Thread(new Runnable(){

   		@Override
   		public void run() {
   			test.methodA();
   			
   		}
   		
   	});
   	t1.start();
   	Thread t2 =new Thread(new Runnable(){

   		@Override
   		public void run() {
   			test.methodB();
   			
   		}
   		
   	});
   	t2.start();
   }

}
/*-  运行结果:
   methodA=0
   methodB=0
   methodA=1
   methodB=1
   methodA=2
   methodB=2
   methodB=3
   methodA=3
   methodA=4
   methodB=4
   */

我们可以看出,结果是A,B是在并行运行,synchronized关键字这里没有体现出来

案例二

1.作用在同一个实例对象test1上,synchronized同步方法测试

2.用不同实例对象(test1和test2)调用不同方法

public class SynchronizedTest1_1 {
	public synchronized void methodA(){
		try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public synchronized void methodB(){
		try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		SynchronizedTest1_1 test1 =new SynchronizedTest1_1();
		//SynchronizedTest1_1 test2 =new SynchronizedTest1_1();
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				//test2.methodB();
			}
			
		});
		t2.start();
	}

}
/*1.实验结果
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
methodB=0
methodB=1
methodB=2
methodB=3
methodB=4
*/2.略

从实验结果,我们可以看出,两个不同的线程,用同一个对象调用不同的方法,并且两个方法都被synchronized修饰,所以这是给同一个对象加锁.是用同一个对象test1分别调用methodA和methodB,此时给methodA给test1加锁,当线程t2,去调用methodB时,要等待test1从methodA中(解锁)释放,此时是串行,
如果是两个对象调用不同的方法就是并行了.,两个对象互不干扰

案例三

作用在同一个实例对象test1上,

public class SynchronizedTest1_2 {
	public synchronized void methodA(){
		try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public synchronized void methodB(){
		try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		SynchronizedTest1_2 test1 =new SynchronizedTest1_2();
		//SynchronizedTest1_2 test2 =new SynchronizedTest1_2();
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				//test2.methodA();
			}
			
		});
		t2.start();
	}

}
/*实验结果
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
*/

从实验结果我们看出,两个线程,但是是同一个对象(test1),调用同一个方法,结果是串行运行,也就是说需要等着test1从上一个线程中释放,下一个才可以使用,但如果是两个不同的对象,就是并行运行,所以这里synchronized锁的是对象(test1).

synchronized同步代码块测试

案例四

作用在同一个实例对象上,
两个线程,一个线程调用synchronized代码块
另一个线程可以调用非synchronized修饰的代码块,

public class SynchronizedTest2 {
	
	public  void methodA(){//方法可以异步运行,进来以后内容同步了
		//同步代码块  this本类对象
		synchronized (this){
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		}
		
	}
	public void methodB(){
		
		try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		SynchronizedTest2 test1 =new SynchronizedTest2();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
	}

}
/*实验结果
methodA=0
methodB=0
methodB=1
methodA=1
methodB=2
methodA=2
methodA=3
methodB=3
methodB=4
methodA=4
*/

从实验结果可以看出,两个互不干扰,并行运行

案例五

作用在同一个实例对象上, synchronized同步代码块测试
两个线程,一个对象调用,两个synchronized修饰的代码块

public class SynchronizedTest2_1 {
	//同步代码块
	public  void methodA(){
		synchronized(this){
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		}
			
		}
		
	
   //给代码块加同步
	public void methodB(){
		synchronized (this){
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		   }catch (Exception e){
			e.printStackTrace();
		   }
		}
		
	}
	public static void main(String[] args) {
		SynchronizedTest2_1 test1 =new SynchronizedTest2_1();
		//SynchronizedTest2_1 test2 =new SynchronizedTest2_1();
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				//test2.methodB();
			}
			
		});
		t2.start();
	}

}
/*实验结果
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
methodB=0
methodB=1
methodB=2
methodB=3
methodB=4
*/

方法并没有被上锁,但内容代码被上锁了,从实验结果可以看出,当线程1执行,test1调用A时被锁住,当A执行完,释放资源之后,test1才可以被线程2使用调用B,所以此时线程1,2是串行的,
但如果是两个不同的对象调用不同的方法时,就是并行的了

synchronized同步代码块测试和同步方法测试

案例六

作用在作用在同一个实例对象上
1,synchronized和synchronized(this)

public class SynchronizedTest3 {
	//给方法加锁
	public synchronized void methodA(){
		
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		
	}
	//给代码块加锁
	public void methodB(){
		synchronized (this) {
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
		}
		
	}
	public static void main(String[] args) {
		SynchronizedTest3 test1 =new SynchronizedTest3();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
	}

}
/*实验结果
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
methodB=0
methodB=1
methodB=2
methodB=3
methodB=4
*/

从实验结果可以看出,synchronized和synchronized(this)二者没有区别,都是作用在this对象上,给this对象加锁,所以会同步,串行运行

案例六

作用在同一个实例对象上, synchronized同步代码块测试和同步方法测试

public class SynchronizedTest3_1 {
	//给方法加锁
	public synchronized void methodA(){
		
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		
	}
	//给代码块加锁
	public void methodB(){
		synchronized (this) {
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
		}
		
	}
	public void methodC(){
		//可以是new任何对象
		Object obj = new Object();
		synchronized (obj) {
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodC="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
		}
		
	}
	
	public static void main(String[] args) {
		SynchronizedTest3_1 test1 =new SynchronizedTest3_1();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
		
		Thread t3 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodC();
				
			}
			
		});
		t3.start();
	}

}
/*实验结果
methodC=1
methodA=2
methodC=2
methodA=3
methodC=3
methodA=4
methodC=4
methodB=0
methodB=1
methodB=2
methodB=3
methodB=4
*/

从实验结果得出synchronized和synchronized(this) 都是作用在this对象上,给this对象加锁而synchronized(obj) 这个是作用在obj对象上,给obj对象添加锁,
所以A和B是串行的,此时C与(A和B)是并行

案例七

作用在同一个实例对象上, synchronized同步代码块测试和同步方法测试

public class SynchronizedTest3_2 {
	private Object obj =new Object();

		//给方法加锁
		public synchronized void methodA(){
			
				try{
				for(int i=0;i<5;i++){
					System.out.println("methodA="+i);
					Thread.sleep(1000);
				}
				
				}catch (Exception e){
				e.printStackTrace();
				}
			
		}
		//给代码块加锁
		public void methodB(){
			synchronized (obj) {
				try{
				for(int i=0;i<5;i++){
					System.out.println("methodB="+i);
					Thread.sleep(1000);
				}
				
			}catch (Exception e){
				e.printStackTrace();
			}
			}
			
		}
	public void methodC(){
		//new任何对象
		
		synchronized (obj){
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodC="+i);
				Thread.sleep(1000);
			}
			
		    }catch (Exception e){
			    e.printStackTrace();
		    }
		  }
		
	}
	public static void main(String[] args) {
		SynchronizedTest3_2 test1 =new SynchronizedTest3_2();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
		Thread t3 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodC();
				
			}
			
		});
		t3.start();
	}

}

/*实验结果
methodA=0
methodB=0
methodA=1
methodB=1
methodA=2
methodB=2
methodB=3
methodA=3
methodA=4
methodB=4
methodC=0
methodC=1
methodC=2
methodC=3
methodC=4
*/

从实验结果可以看出synchronized修饰的A方法针对的是this对象,而B和C中的synchronized(obj)代码块修饰的是obj对象,所以,methodB和methodC是串行,锁上在obj上,methodA跟(B和C)是并行的

作用在同一个类上,一个类上只有一把锁

案例八

synchronized类锁
static synchronized 和 synchronized(类名.class)

public class SynchronizedTest4 {
	//static的修饰的方法属于类
	public synchronized static  void methodA(){//加静态就锁在类上了
		//同步代码块
		
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		
	}
	public void methodB(){
		synchronized (SynchronizedTest4.class){//修饰在类上了
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
		}
		
	}
	public static void main(String[] args) {
		SynchronizedTest4 test1 =new SynchronizedTest4();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
	}

}
/*
methodA=0
methodA=1
methodA=2
methodA=3
methodA=4
methodB=0
methodB=1
methodB=2
methodB=3
methodB=4
*/

有结果可以看出,static修饰的属于类,所以都是作用在同一个类锁,所以会同步,是串行,

案例九

synchronized的对象锁和static静态的synchronized的类锁

public class SynchronizedTest5 {
	public synchronized  void methodA(){
		
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodA="+i);
				Thread.sleep(1000);
			}
			
			}catch (Exception e){
			e.printStackTrace();
			}
		
	}
	public void methodB(){
		synchronized (SynchronizedTest5.class){
			try{
			for(int i=0;i<5;i++){
				System.out.println("methodB="+i);
				Thread.sleep(1000);
			}
			
		}catch (Exception e){
			e.printStackTrace();
		}
		}
		
	}
	public static void main(String[] args) {
		SynchronizedTest5 test1 =new SynchronizedTest5();
		
		Thread t1 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodA();
				
			}
			
		});
		t1.start();
		Thread t2 =new Thread(new Runnable(){

			@Override
			public void run() {
				test1.methodB();
				
			}
			
		});
		t2.start();
	}

}
/*实验结果
methodA=0
methodB=0
methodB=1
methodA=1
methodA=2
methodB=2
methodA=3
methodB=3
methodA=4
methodB=4
*/

由结果可以看出,synchronized修饰的属于对象锁而static synchronized的属于类是两个不同的锁,所以是异步的,并行运行

总结:

多个线程,在用同一个对象,调用有synchronized关键字修饰的方法或代码块时,我们要注意,这把锁是给哪个对象,(这个对象属于方法的),被锁住的对象需要在解锁后才可以被其他带锁的方法或代码块使用,此时是串行运行,但是如果其他线程中该对象调用的是其他不带synchronized修饰的方法或代码块时,此时是并发运行的.
synchronized修饰类时有两种形式static synchronized 和 synchronized(类名.class),此时,对象是属于类的,在遇到只有synchronized修饰的方法时,两者对象的归属不同所以是可以并发运行的
String作为锁对象时要慎用

Logan_addoil
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java句柄数过高怎么解决_Java高并发，如何解决？什么方式解决？ | 文末送书
weixin_39633252的博客
11-29 1225
点击上方“JAVA”，星标公众号重磅干货，第一时间送达对于我们开发的网站，如果网站的访问量非常大的话，那么我们就需要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题，但话又说回来了，既然逃避不掉，那我们就坦然面对吧~今天就让我们一起来研究一下常见的并发和同步吧。为了更好的理解并发和同步，我们需要先明白两个重要的概念：同步和异步1. 同步和异步的区别和联系所谓同步，可以理解...
【Java】synchronized同步锁详解
12-22
synchronized同步锁（悲观锁）2.1 synchronized 作用范围2.2 synchronized 核心组件2.3 synchronized 实现 1. Java锁的种类 1.1 乐观锁 乐观锁是一种乐观思想，即认为读多写少，遇到并发写的可能性低。 每次去拿...
【VUE踩坑记录】vue中axios调用接口，浏览器中的status显示为canceled
LYQ
03-15 8401
在维护一个同事开发的项目的时候发现一个问题，每次发送对应功能点的请求都会有个别请求的status的请求状态为canceld。 顺便看了一下同事的逻辑，大致上是没有问题的，由于部分请求需要上一个请求返回的值做参数，而vue默认是异步的，所以加了同步锁。 然后看了一下同事跳转路由的方式，发现她是用的window.open()方法来进行路由跳转 而使用window.open()方法来进行路由跳转的页面数据载入是异步的，这样导致了前端在调用前面几个接口的时候异步走了window.open()方法.
synchronized同步锁的三种方式
qq_41800568的博客
08-13 5008
不多说，直接上代码 import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 铁道部发布了一个售票任...
同步锁的三种实现与案例解析
稚枭天卓
12-17 7329
1、同步和异步的区别和联系 所谓同步，可以理解为在执行完一个函数或方法之后，一直等待系统返回值或消息，这时程序是出于阻塞的，只有接收到返回的值或消息后才往下执行其它的命令。         异步，执行完函数或方法后，不必阻塞性地等待返回值或消息，只需要向系统委托一个异步过程，那么当系统接收到返回值或消息时，系统会自动触发委托的异步过程，从而完成一个完整的流程。          同步在一定程
关于同步锁的一个问题
峰行天下
04-22 730
问题发生日期           2015-03-20 问题简述 当高并发情况下， 10万次的抽奖场景下，  共抽奖142606次 ， 统计汇信T恤，初始化5w件 ， 数据库统计，获奖记录中奖品为汇信T恤的有4190条记录 后台剩余数量为46136件 大于5w。 解决方案详细描述 在抽奖方法内部，针对数据库奖品库存操作和抽奖时对数据库的操作等抽奖
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
Java:synchronized锁住的是代码还是对象
12-22
在Java中，synchronized关键字是用来控制线程同步的，是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。Synchronized既可以对代码块使用，也可以加在整个方法上。 　关键是，不要认为给方法或者...
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
python多线程同步教程_Python利用多线程同步锁实现多窗口订票系统(推荐)
weixin_36325615的博客
02-10 363
这篇文章主要介绍了Python利用多线程同步锁实现多窗口订票系统,主要是利用threading.lock()通过实例代码相结合给大家讲解的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下利用Python实现多窗口订票系统，利用threading.Lock()避免出现一票多卖，无票也卖的情况，并规范化输出情况。代码：import threadingimport timetickets, loc...
python实现synchronized
a1053904672的博客
05-29 4628
利用python的装饰器实现类似java中的synchronized from threading import Lock,Thread from functools import wraps default_lock=Lock() lock_list={'default':Lock()} def synchronized(func=None,obj=None): if func i...
Oracle数据库之间数据同步
我飞故我在的专栏
06-25 3257
Oracle数据库之间数据同步
java线程、线程池，类、对象锁 java线程通信，线程的状态 wait/notify
emmmsuperdan的博客
03-23 5859
同步：发送一个指令，需要等待返回结果，才能发出下一个指令，需要等待； 异步：发送一个指令，不需要等待，即可直接发出下一个指令； 一般情况下，都采用异步，效率更高；但是比如说银行系统，必须采用同步，这样才能保证数据的共享和安全性； synchronize关键字： 每个 synchronized 方法都必须获得调用该方法的类实例的锁（或者类锁）方能执行，否则所属线程阻塞；直到synchr...
锁和同步的区别
学亮编程手记
02-08 1491
● 请说明一下锁和同步的区别。 考察点：锁 参考回答： 用法上的不同： synchronized既可以加在方法上，也可以加载特定代码块上，而lock需要显示地指定起始位置和终止位置。 synchronized是托管给JVM执行的，lock的锁定是通过代码实现的，它有比synchronized更精确的线程语义。 性能上的不同： lock接口的实现类ReentrantLock，不仅具有和synchro...
同步锁与异步锁的区别
热门推荐
nicknailo博客
09-25 3万+
异步锁：同一进程内的，多个线程间有互斥关系。只有等一个线程运行结束才能运行运行另一个进程。 同步锁：多个线程运行一个方法，因为方法上加了同了同步，一次只有一个线程运行，其他线程进入竞争进制。    同步是一种更为复杂的互斥，而互斥是一种特殊的同步。 本质：等待响应 比方说同步（读写）锁特点：1）多个读者可以同时进行读 2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行） 3）写者优
python多线程使用lock实现同步
timothytt的博客
04-04 1496
一直在想，python和java的synchronized等价的是什么，怎么实现同步呢？ 为了测试同步，我们用5个线程同时进行累加，每次加1进行1000000次。 如果同步成功，那么结果是5000000。 我们分别用正确的lock加锁方式，不加锁，错误的加锁方式来进行对比。 正确的加锁方式：target_function1 不加锁：target_function2 错误的...
oracle锁机制代码理解,Oracle数据一致性之锁机制（一）
weixin_32687875的博客
04-04 106
先来了解一下锁的概念，锁是保证数据一致性的一种机制，其实现过程由oracle自动完成，多用户模式下，锁有两种模式：排他锁(exclusive lock)模式：能够阻止共享被加锁的资源。对数据进行修改时必须获得此种模式的锁。第一个排他地对资源加锁的事物是唯一可以对此资源进行修改的事物，直至排他锁被释放。共享锁(share lock)模式：依据操作类型有条件地允许共享被加锁的资源。对数据进行读取的多个...
python里协程使用同步锁Lock
大坡3D软件开发
09-09 7156
尽管asyncio库是使用单线程来实现协程的，但是它还是并发的，乱序执行的。可以说是单线程的调度系统，并且由于执行时有延时或者I/O中断等因素，每个协程如果同步时，还是得使用一些同步对象来实现。比如asyncio就定义了一个锁对象Lock，它一次只允许一个协程来访问共享的资源，如果多协程想访问就会阻塞起来，也就是说如果一个协程没有释放这个锁，别的协程是没有办法访问共享的资源。例子：import a
synchronized是同步锁吗
最新发布
02-28
是的，synchronized是Java中的关键字，用于实同步锁机制。当一个方法或者一个代码块被synchronized修饰时，它变成了一个临区，同一时间只能有一个线进入该临界区执行代码，其他线程需要等待。这样可以保证多个线程在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值