如何检查线程是否在同步块或方法内？ [英] How can I check if a thread is inside a synchronized block or method?

问题描述

我的Java应用程序使用两个线程。历史上成长的，有使用中的同步方法和专用锁对象。我需要知道当前线程有一个锁，如果它是通过方法或对象。

解决方案

当输入同步方法时，VM会对当前对象设置锁定。因此，以下代码具有相同的效果：

 同步void syncMethod（）{
 // do something 
} 
 
 void syncManually（）{
 synchronized（this）{
 // do something 
} 
} 
  
 
 
 
这意味着synchronized方法与
完全一样
 
 
 同步（锁）{
 //做某事
} 
  
 
 
 < 
 
 
 
您可以使用 Thread.holdsLock（...）线程持有特定的锁。这里是一个示例代码：
  final Object lock = new Object（）; 
 
 public void lockDemo（）{
 
 System.out.println（Thread.holdsLock（lock））; // false 
 System.out.println（Thread.holdsLock（this））; // false 
 
 synchronized（lock）{
 System.out.println（Thread.holdsLock（lock））; // true：被对象锁定
 System.out.println（Thread.holdsLock（this））; // false 
} 
 
 doSyncMethod（）; 
} 
 
 public synchronized void doSyncMethod（）{
 System.out.println（Thread.holdsLock（lock））; // false 
 System.out.println（Thread.holdsLock（this））; // true：通过同步方法锁定
} 
  
 
 
 < a $ href =http://download.oracle.com/javase/6/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html> ReentrantReadWriteLock 受 java.util.concurrent.locks 包。 
它们可以提供单独的读和写锁定，并提高应用程序的性能。 Oracle Java教程的锁定对象一章是一个很好的开始。
 
My Java application uses two Threads. Historically grown, there are synchronized methods and dedicated lock objects in use. I need to know wether the current thread has a lock and if it is by method or object. How can I do this?
解决方案
When entering a synchronized method the VM sets a lock on the current object. Thus the following codes have the same effect:
synchronized void syncMethod() {
    // do something
}

void syncManually() {
    synchronized (this) {
        // do something
    }
}
That means the synchronized method does exactly the same as
synchronized( lock ) {
    // do something
}
anywhere in your code.

You can use Thread.holdsLock(...) to check if the thread holds a specific lock. Here is an example code:
final Object lock = new Object(); 

public void lockDemo() {

    System.out.println( Thread.holdsLock(lock) );     // false
    System.out.println( Thread.holdsLock(this) );     // false

    synchronized ( lock ) { 
      System.out.println( Thread.holdsLock(lock) );   // true: locked by object
      System.out.println( Thread.holdsLock(this) );   // false
    }

    doSyncMethod();
}

public synchronized void doSyncMethod() {
    System.out.println( Thread.holdsLock(lock) );  // false
    System.out.println( Thread.holdsLock(this) );  // true: locked by synchronized method
}
Since Java 1.5 more sophisticated locks like ReentrantReadWriteLock are supported by the java.util.concurrent.locks package.
They can provide separated read and write locking and improve the performance of your application. The Lock Objects chapter of the Oracle Java Tutorials is a good start here.

                        
这篇关于如何检查线程是否在同步块或方法内？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！