同一任务和对象锁的问题

maozj

浏览: 324762 次
性别:
来自: 西宁

最近访客更多访客>>

wyx065747

penguinwcc

tangluyou

zkhero丶

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java Thought

多线程 thread JVM 编程虚拟机

   偶尔翻开java编程思想看看多线程的篇章，意焦突然卡在某个问题上不动了。这个问题看过多少次多少遍了，此刻才领会，顿时感觉自己好笨拙的思维。

    问题是这样的：一般来说，在多线程程序中，某个任务在持有某对象的锁后才能运行任务，其他任务只有在该任务释放同一对象锁后才能拥有对象锁，然后执行任务。于是，想到，同一个任务在持有同一个对象的锁后，在不释放锁的情况下，继续调用同一个对象的其他同步(synchronized)方法，该任务是否会再次持有该对象锁呢？

    答案是肯定的。同一个任务在调用同一个对象上的其他synchronized方法，可以再次获得该对象锁。

    多线程编程是一件很微妙的事情，这里考验人的不是大局而是细节，细节的细节。希望能唤醒自己愚笨的思维。

 package thread.thread1;

/**
 * 同一任务可以再次持有对象锁 create on 2010.08.04 08:27
 * 
 * @since jdk1.6
 * @author maozj
 * @version 1.0
 * 
 */
public class SynchronizedClassHolder {
	/**
	 * Test client
	 * @param args
	 */
	public static void main(String[] args) {
		new Thread() {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();
	}

	private static int count = 10;

	/**
	 * synchronized f1()
	 */
	public synchronized void f1() {
		if (--count > 0) {
			System.out.println("f1() calling f2() count " + count);
			f2();
		}
	}

	/**
	 * synchronized f2()
	 */
	public synchronized void f2() {
		if (--count > 0) {
			System.out.println("f2() calling f1() count " + count);
			f1();
		}
	}
}

输出：
f1() calling f2() count 9
f2() calling f1() count 8
f1() calling f2() count 7
f2() calling f1() count 6
f1() calling f2() count 5
f2() calling f1() count 4
f1() calling f2() count 3
f2() calling f1() count 2
f1() calling f2() count 1

分享到：

系统管理员必备的法则 | 前台页面布局复用一点建议

2010-08-04 08:31
浏览 2545
评论(37)
论坛回复 / 浏览 (37 / 13690)
分类:编程语言
查看更多

37 楼 kind790 2010-08-06

whoamiwangwb 写道

public class SynchronizedClassHolder {

	public static void main(String[] args) {
		new Thread("thread 1") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();

		new Thread("thread 2") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();
	}

	private static int count = 10;

	public synchronized void f1() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f1() calling f2() count " + count);
			f2();
		}
	}

	public synchronized void f2() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f2() calling f1() count " + count);
			f1();
		}
	}
}

显示的结果：

thread 1    f1() calling f2() count 9
thread 2    f1() calling f2() count 8
thread 2    f2() calling f1() count 6
thread 2    f1() calling f2() count 5
thread 2    f2() calling f1() count 4
thread 2    f1() calling f2() count 3
thread 2    f2() calling f1() count 2
thread 1    f2() calling f1() count 7
thread 2    f1() calling f2() count 1

这个怎么解释呢？
jvm 1.6.0.18

两回事情，请看看楼主的问题哦。呵呵
当多个线程使用同一个对象调用此对象的同步方法时才需要竞争（当前）对象锁，此时同步才有意义；现在的问题是两个线程使用各自的对象调用各自对象的同步方法了。

36 楼 wkoffee 2010-08-05

whoamiwangwb 写道

public class SynchronizedClassHolder {

	public static void main(String[] args) {
		new Thread("thread 1") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();

		new Thread("thread 2") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();
	}

	private static int count = 10;

	public synchronized void f1() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f1() calling f2() count " + count);
			f2();
		}
	}

	public synchronized void f2() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f2() calling f1() count " + count);
			f1();
		}
	}
}

你这个程序根本没有同步，两个线程都是只对自己的SynchronizedClassHolder加锁，synchronized根本没有意义

35 楼 piao_bo_yi 2010-08-05

就是由编译器搞的互斥量或二元信号量，看JAVA里面的描述想理解这个话题，说心里话，很难。

34 楼 mercyblitz 2010-08-05

whoamiwangwb 写道

是不是说，在从f1调用f2的时候，出现的释放+重新获取的动作呢？

没有，代码中没有wait这样的操作，不会出现释放锁的行为。

33 楼 yangjitang100 2010-08-05

对象锁分持有和非持有，持有状态有有不同情况，访问一个同步方法则指数加一，反之减一，所以当一个任务持有对象锁之后再次访问该对象的的同步方法则指数加一，不会死锁。

32 楼 whoamiwangwb 2010-08-05

是不是说，在从f1调用f2的时候，出现的释放+重新获取的动作呢？

31 楼 whoamiwangwb 2010-08-05

public class SynchronizedClassHolder {

	public static void main(String[] args) {
		new Thread("thread 1") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();

		new Thread("thread 2") {
			public void run() {
				new SynchronizedClassHolder().f1();
			}
		}.start();
	}

	private static int count = 10;

	public synchronized void f1() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f1() calling f2() count " + count);
			f2();
		}
	}

	public synchronized void f2() {
		if (--count > 0) {
			System.out.println(Thread.currentThread().getName()
					+ "    f2() calling f1() count " + count);
			f1();
		}
	}
}

30 楼 coreymylife 2010-08-04

感觉应该是这样的，当执行synchronized方法的时候，先判断该线程是否拥有锁，如果没有锁则获取锁。如果已经拥有了则执行。

29 楼笑我痴狂 2010-08-04

我不得不说一句

这里的f1调用f2是同一把锁吧在加锁的f1中调用f2 这把锁根本就未曾释放过知道运行完也就是当count<0为止

28 楼 xuyan2680 2010-08-04

mercyblitz 写道

hardPass 写道

mercyblitz 写道

hardPass 写道

对于单线程来说，synchronized锁是可重入的

重进入是针对多线程的，单线程synchronized还有什么意义？

说实话，我到现在为止，也没有明白，我们常说的可重入锁是什么意思？

这个 “重”是指 “多个线程”同时进入同1个锁？这个类似 readLock
还是指单个线程同时进入“多个”被“锁”住的代码块？这个类似synchronized，如果硬要咬文嚼字，这里确实不应该说是“可重入”，
用其他词，好像也不够酷。

”可重入“很形象的，好比方法的递归。如果一个线程获得锁之后，我们常说的synchronized块下的代码块就是临界区，在这个临界区内部所有的方法调用都是同步的。这点不难明白，但是块中方法调用还有synchronized修饰的块或者方法，哪么线程不需要重复获得锁。简单地说，如果一个线程第一次进入了synchronized块，接下来的动作中，线程再次进入synchronized块不会重复获得锁。

正解！

27 楼 mercyblitz 2010-08-04

lxs647 写道

多次获取同一对象的锁后，释放的时候也是要释放多次？？还是一次释放掉所有的对象锁？？

只有一个锁，这个锁是线程所有，并不是monitor对象。只会释放一次。

26 楼 lxs647 2010-08-04

多次获取同一对象的锁后，释放的时候也是要释放多次？？还是一次释放掉所有的对象锁？？

25 楼 zy2419 2010-08-04

没有再次持有吧,调用同步方法必须持有此对象锁,而此对象锁已经持有了.

24 楼 rain2005 2010-08-04

可重入锁ReentrantLock是使用计数器变量，notify wait实现的。
synchronized没有计数器的概念。

23 楼 hatedance 2010-08-04

<div class="quote_title">michael.softtech 写道</div>
<div class="quote_div">
<p>我是这样理解的。 Java Monitors Are Reentrant 也就是当前线程如果已经有了一个Object a的锁，那么此线程想再次获取这个a的锁时，可以继续获取。然后在此线程对于该锁的计数上+1. 比如</p>
<p> </p>
<pre name="code" class="java">synchronized m1(){
//加入此时对锁a的计数是N
m2(); //进入m2的方法体之后锁计数是N+1,离开m2后是N
}
synchronized m2(){}</pre>
<p> 这样就能保证锁的正确获取和释放了。</p>
<p> </p>
<p> 个人理解，仅供参考～</p>
</div>
<p>说的没错。我在《java concurrency in practice》一书里得到了验证:</p>
<p>
</p>
<div class="quote_title">
<span style="font-weight: normal;">《java concurrency in practice》:</span> 写道</div>
<div class="quote_div">2.3.2. Reentrancy<br>When a thread requests a lock that is already held by another thread, the requesting thread blocks. But <strong>because intrinsic locks are reentrant, if a thread tries to acquire a lock that it already holds, the request succeeds.</strong> Reentrancy means that locks are acquired on a <strong>per-thread</strong> rather than <strong>per-invocation</strong> basis. [7] Reentrancy is implemented by associating with each lock an acquisition count and an owning thread. When the count is zero, the lock is considered unheld. When a thread acquires a previously unheld lock, the JVM records the owner and sets the acquisition count to one. If that same thread acquires the lock again, the count is incremented, and when the owning thread exits the synchronized block, the count is decremented. When the count reaches zero, the lock is released.<br>
</div>

22 楼 mercyblitz 2010-08-04

hardPass 写道

mercyblitz 写道

hardPass 写道

对于单线程来说，synchronized锁是可重入的

重进入是针对多线程的，单线程synchronized还有什么意义？

21 楼 mercyblitz 2010-08-04

beneo 写道

看了半天原来对象锁是monitor，妈的翻译害死人

Java 1.5以后的Lock实现，确实可以带来一定帮助。较前面的synchronized而言，synchronized可以监视多个monitor对象，当monitor对象释放锁顺序不正确，会发生死锁。而Lock对象，monitor是其本身，相对而言，更容易检测。

20 楼 hardPass 2010-08-04

mercyblitz 写道

hardPass 写道

对于单线程来说，synchronized锁是可重入的

重进入是针对多线程的，单线程synchronized还有什么意义？

19 楼 mercyblitz 2010-08-04

mercyblitz 写道

hardPass 写道

asialee 写道

hardPass 写道

maozj 写道

同一个任务在调用同一个对象上的其他synchronized方法，可以再次获得该对象锁。

是这样的吗？

我一直认为是，已经持有锁了，可以继续执行synchronized方法。
不是你说的“可以再次获得该对象锁”。

应该是采用的是引用计数的方法来实现的课重入。

计数？统计什么？记录下同一个线程 Monitor entered 了几次？
但是，这个计数器有什么用呢？又不是类似readlock的东西，可以多个线程同时持有锁。
而且这个synchronized根本不需要显示的声明释放锁。
所以我认为，即使是jvm底层实现，也没有必要进行计数。

或许吧，可能jvm底层实现，是有计数器，那只是可能，并且与开发人员没有关系，没有必要知道。

synchronized方法和块中，都是开辟了“临界区”，重复进入相同的“临界区”，确实需要计数。当进入时+1，退出是-1。

补充一点，如果synchronized定义的方法是对象方法，哪么锁就在加载this对象上。如果是类方法的话，锁就在该类之上。所谓重进入就是从第一个synchronized开始，不断地进入了synchronized块或者方法，尽管synchronized可以监视不同的monitor。而monitor是用于wait/notify通知机制。

18 楼 beneo 2010-08-04

看了半天原来对象锁是monitor，妈的翻译害死人

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论