java 线程中的静态同步和非静态同步方法
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/5654654/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
static synchronized and non static synchronized methods in threads
提问by satheesh
can any one explain the statement ..."static synchronized method and non static synchronized method will not block each other -they can run at the same time"
谁能解释一下这句话...“静态同步方法和非静态同步方法不会互相阻塞——它们可以同时运行”
回答by atamanroman
static synchronized void test() { foo(); }
equals
等于
static void test() { synchronized(MyClass.class) { foo(); } }
while
尽管
synchronized void test() { foo(); }
equals
等于
void test() { synchronized(this) { foo(); } }
This means: static methods lock on the class object of the class. Non-static methods lock on the instance on which they're called (by default, synchronized(anyOtherLock)is also possible). Since they lock on different objects, they don't block each other.
这意味着：静态方法锁定在类的类对象上。非静态方法锁定调用它们的实例（默认情况下，synchronized(anyOtherLock)也是可能的）。由于它们锁定在不同的对象上，因此它们不会相互阻塞。
回答by Chris Dennett
The lock objects are different on the static method and non-static method. The static method uses the Class object as the lock (lock obj: MyClass.class), while the non-static method uses the instance object as the lock to which the invocation of the method at that time is bound (lock obj: this).
静态方法和非静态方法上的锁对象是不同的。静态方法使用Class对象作为锁（lock obj: MyClass.class），而非静态方法使用实例对象作为当时方法调用所绑定的锁（lock obj: this）。
回答by upadhyayRakes
non static synchronized methods put monitor lock on 'this'- It means only current object is locked.so all threads associated with current object will be blocked to access non static sync methods of that class if any one thread is accessing non static synchronized method. while other object's threads can still access the methods.
非静态同步方法将监视器锁放在“this”上——这意味着只有当前对象被锁定。因此，如果任何一个线程正在访问非静态同步方法，则与当前对象关联的所有线程都将被阻止访问该类的非静态同步方法。而其他对象的线程仍然可以访问这些方法。
And static synchronized methods put monitor lock on Class object- It means if a thread of any object is accessing the method than all threads irrespective of any objects will be blocked to access all static synchronized methods of the class.
静态同步方法将监视器锁放在类对象上——这意味着如果任何对象的线程正在访问该方法，那么无论任何对象如何，所有线程都将被阻止访问该类的所有静态同步方法。
public class TestSync {
公共类 TestSync {
public synchronized void n1(int threadId)
{
snooze(threadId);
System.out.println("Sync non static n1 " + threadId);
}
public void n2(int threadId)
{
snooze(threadId);
System.out.println(" non static n2 " + threadId);
}
public static synchronized void s1(int threadId)
{
snooze(threadId);
System.out.println("Sync static s1 "+ threadId);
}
public static void s2(int threadId)
{
snooze(threadId);
System.out.println(" static s2 "+ threadId);
}
static void snooze(int threadId)
{
System.out.println("Waiting ... "+ threadId);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
TestSync ob = new TestSync();
TestSync ob2=new TestSync();
TestSync ob3=new TestSync();
TestSync ob4=new TestSync();
Runnable r1=()-> {
/*ob.n1(10);
ob.n2(10);*/
ob.s1(10);
//ob.s2(10);
};
Runnable r3=()-> {
/*ob2.n1(30);
ob2.n2(30);*/
ob2.s1(30);
//ob2.s2(30);
};
Runnable r4=()-> {
/*ob3.n1(40);
ob3.n2(40);*/
ob3.s1(30);
//ob3.s2(30);
};
Thread t1=new Thread(r1);
Thread t2= new Thread(r2);
Thread t3= new Thread(r3);
Thread t4= new Thread(r4);
Thread t5= new Thread(r5);
t1.start();
t3.start();
t4.start();
}
} Run once for static synchronized and than uncomment the non-static synchronized calls(and comment static synchronized) in runnable and run. You will understand better.
为静态同步运行一次，然后在 runnable 和 run 中取消注释非静态同步调用（和注释静态同步）。你会更好地理解。
