面试官问：同类不同方法加同步锁，多个线程支持同时访问吗？

于 2023-10-01 22:00:25 发布
阅读量86 收藏 2
点赞数
文章标签： java 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzAwMTE3MDY4MQ==&mid=2652471891&idx=2&sn=c1cbf86f7964e3890adfdcd51bc555e9&chksm=8130efc5b64766d39cce822d57c87d70dd0fc12513bcd43ed11233bf143ba4ac5c5879992418&scene=126&sessionid=0
版权

看到这个问题第一反应是不懂，然后查询了网上的一些说法，感觉略有不一。细看之下发现大家对这个问题的分析角度不太一样，就会出现不同的结果，在这里记一下我收集来的不同的角度和自己的例子，感觉这个题目还是蛮有意思的。

首先，同步锁有两种，JVM的synchronized和JDK的ReentrantLock；

然后，多个线程访问这个类的两个方法也有不同的形式，例如访问这个类的两个方法是通过同一个类的实例对象来访问还是通过不同的类的实例对象访问；

再者，一个类的两个方法加了同步锁，这两个被同步方法也没有说明是什么样的方法。他可能是类的普通实例方法，也可能是类中Runnable对象的run方法。

看到这里也许会觉得我对于问题过于的咬文嚼字，但是我想要探讨更多的可能，不同的情形有着不同的结果，而且这些不同的情形能开拓思路，让我们看问题能多个角度，也可以帮我加深多线程的理解。如果本文中有错误或者不恰当的例子，或者代码写的不严谨不规范风格不好，都可以留言提出。

一. synchronized

1.多个线程同时访问同一个类实例对象的两个同步方法：

package synchronizedTest;

public class Example1 {
	private int num = 0 ;
	(省略getter.setter，后同)
	public synchronized void method1() {
		System.out.println("同步方法1进入");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("同步方法1:"+num+"--");
			num++ ;
		}
		System.out.println("同步方法1结束");
	}
	
	public synchronized void method2() {
		System.out.println("method2进入:");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("method2:"+num+"--");
			num++ ;
		}
		System.out.println("method2结束");
	}
	
	public static void main(String[] args) {
		final Example1 example1 = new Example1() ;
		
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method2();
			}
		}) ;
		try {
			thread2.join();
			thread1.join();			
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
	
}

输出结果：

method1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--method1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

显然此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的

推荐下自己做的 Spring boot 的实战项目：
https://gitee.com/yoodb/jing-xuan‍

2.多个线程同时访问同一个类的不同实例对象的两个同步方法：

将上面的代码稍作修改，主函数中多new一个该类实例

final Example1 example2 = new Example1() ;

再修改thread2的run方法调用的类实例为example2

Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();
			}
		}) ;

得到结果：

同步方法1进入
method2进入:
method2:0--method2:1--同步方法1:0--同步方法1:1--同步方法1:2--method2:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--method2:5--同步方法1:6--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--method2:7--同步方法1结束
method2:8--method2:9--method2结束

这时候显然，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。另外，更多面试题推荐公众号Java精选，回复java面试，获取最新面试题资料，支持在线随时随地刷题。

小结：这是因为synchronized是对象锁，即线程获得的锁是施加在一个实例对象上的，如果不同的线程访问的是同一对象上的不同的同步方法，那么显然不能同时进行。

如果是不同对象上的不同的同步方法，那么就是可以同时进行的。

3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：

package synchronizedTest;

public class Example2 {
	private int num ;
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("线程1进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("线程1:"+num+"--");
				}
				System.out.println("线程1结束");
			}
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("thread2进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("thread2:"+num+"--");
				}
				System.out.println("thread2结束");
			}
		}
	};
	
	public static void main(String[] args) {
		Example2 example = new Example2() ; //创建一个对象
		new Thread(example.runnable1).start(); //同步方法1
		new Thread(example.runnable2).start(); //同步方法2
	}
}

输出结果：

thread2进入
线程1进入
thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--线程1结束
thread2结束

可见此时多个线程是能同时访问同个类的两个同步方法的。这是因为

synchronized(this){ //... }中锁住的不是代码块，即这个锁在run方法中，但是并不是同步了这个run方法，而是括号中的对象this,也就是说，多个线程会拿到各自的锁，就能够同时执行run方法。(在run方法前声明synchronized也是同样的效果)

new Thread(example.runnable1).start(); //同步方法1
new Thread(example.runnable2).start(); //同步方法2

打印出这个this对象，是两个不同的类实例对象：

synchronizedTest.Example2$1@65db6dfa
synchronizedTest.Example2$2@471fab

也说明了不同线程的实例对象不同，都是各自对象的锁，不可以认为是类似于例子1中的同一实例对象，而应该类似与例子2的不同类的实例对象。

推荐划水摸鱼神器：

https://www.yoodb.com/slack-off/home.html

总结：分析synchronized同步锁的核心在于他是个对象锁，找清楚锁的对象

二. ReentrantLock锁

1.多个线程同时访问同一个类实例对象的两个同步方法：

将例子1的synchronized改为引入ReentrantLock

package ReentrantLockTest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
	private int num;
	private Lock lock = new ReentrantLock();

	public void method1() {
			lock.lock();
			System.out.println("同步方法1进入");
			for(int i = 0 ; i<10 ; i++) {
				System.out.print("同步方法1:"+num+"--");
				num++ ;
			}
			System.out.println("同步方法1结束");
			lock.unlock();
	}

	public void method2() {
		lock.lock();
		System.out.println("method2进入:");
		for (int i = 0; i < 10; i++) {
			System.out.print("method2:" + num + "--");
			num++;
		}
		System.out.println("method2结束");
		lock.unlock();
	}

	public static void main(String[] args) {
		final LockExample example = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method2();
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

输出结果：

同步方法1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--同步方法1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

可见此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的

2.多个线程同时访问同一个类的不同实例对象的两个同步方法：

修改main函数的即可：

public static void main(String[] args) {
		final LockExample example1 = new LockExample() ;//两个实例
		final LockExample example2 = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1(); //实例1的同步方法1
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();//实例2的同步方法2
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

输出结果：

同步方法1进入
method2进入:
同步方法1:0--method2:0--method2:1--同步方法1:1--method2:2--同步方法1:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--同步方法1:6--method2:5--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--同步方法1结束
method2:7--method2:8--method2:9--method2结束

可见，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。

总结：ReentrantLock和synchronized的前两个例子结论都相同

3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：

package ReentrantLockTest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Lockexample2 {

	private int num;
	private Lock lock = new ReentrantLock();
	
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("线程1进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("线程1:"+num+"--");				
			}
			System.out.println("线程1结束");
			lock.unlock();
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("thread2进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("thread2:"+num+"--");
			}
			System.out.println("thread2结束");
			lock.unlock();
		}
	};
	
	public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example.runnable2).start(); 
		
	}
}

输出结果：

线程1进入
线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1结束
thread2进入
thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2结束

这里可以看到，与synchronized的第三个例子出现了不同的结果。在这个地方，ReentrantLock不允许多线程同时访问一个类的不同同步方法。

推荐划水摸鱼神器：

https://www.yoodb.com/slack-off/home.html

这里要注意的是ReentrantLock与synchronized不同，ReentrantLock的实现方式是要先创建ReentrantLock对象，然后用这个对象的方法来上锁。而一个类的实例中只有一个ReentrantLock对象：

private Lock lock = new ReentrantLock();

而本例中，线程的创建是建立在同一个类实例上的：

Lockexample2 example = new Lockexample2();
new Thread(example.runnable1).start(); 
new Thread(example.runnable2).start();

因此，ReentrantLock对象lock是同一个，因此第一个线程进入同步方法1后就获取了锁，第二个线程无法获取这个锁，只能等待。

如果换成是两个实例对象：

public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		Lockexample2 example2 = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example2.runnable2).start(); 
		
	}

输出结果

线程1进入
thread2进入
线程1:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2结束
线程1:0--线程1结束

可见不同的实例对象中是不同的ReentrantLock对象，因此可以同时访问

小结：ReentrantLock锁的核心在与ReentrantLock对象是不是同一个。

三. 结论

重新看看这个问题：一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的两个方法吗？

现在应该比较清楚了，这个问题要分成synchronized和ReentrantLock两个情况：

1、对于synchronized

1）一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法

2）一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法

3）一个类中的两个方法**（Runnable的run方法）都加了同步锁，多个线程能**同时访问这个类的两个方法（不论是不是同一实例对象）

2、对于ReentrantLock

1）一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法（不论同步加在实例方法中或是run方法中）

2）一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法（不论同步加在实例方法中或是run方法中）

版权声明：本文为CSDN博主「Geepyyyy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

https://blog.csdn.net/weixin_40616523/article/details/87883267

公众号“Java精选”所发表内容注明来源的，版权归原出处所有（无法查证版权的或者未注明出处的均来自网络，系转载，转载的目的在于传递更多信息，版权属于原作者。如有侵权，请联系，笔者会第一时间删除处理！
最近有很多人问，有没有技术或摸鱼交流群！加入方式很简单，公众号Java精选，回复“加群”，即可入群！在线摸鱼：https://www.yoodb.com/

Java精选面试题（微信小程序）：3000+道面试题，包含Java基础、并发、JVM、线程、MQ系列、Redis、Spring系列、Elasticsearch、Docker、K8s、Flink、Spark、架构设计等，在线随时刷题！
------ 特别推荐 ------
特别推荐：专注分享最前沿的技术与资讯，为弯道超车做好准备及各种开源项目与高效率软件的公众号，「大咖笔记」，专注挖掘好东西，非常值得大家关注。点击下方公众号卡片关注。

点击“阅读原文”，了解更多精彩内容！文章有帮助的话，点在看，转发吧！
Java精选
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值