如果我在同一个类上同步了两个方法，它们可以同时在同一个对象上运行吗？例如：
class A {
public synchronized void methodA() {
//method A
}
public synchronized void methodB() {
// method B
}
}
我知道我不能在两个不同线程中对同一个对象运行两次methodA()。 methodB() 中的相同内容。
但是我可以在 methodA() 仍在运行时在不同的线程上运行 methodB() 吗？ （同一个对象）
【问题讨论】：
标签： java multithreading synchronized java-threads
这两种方法都会锁定同一个监视器。因此，您不能同时在不同线程的同一个对象上执行它们（两种方法中的一种会阻塞，直到另一种完成）。
【讨论】：
methodB() 是static 时，obj.methodB() 是A.methodB() 的同义词。因此，是的，它们会阻塞（在类的而不是对象的监视器上）。
.class 对象使用锁定。所以如果你有class A {static synchronized void m() {} }。然后一个线程调用new A().m() 它获取new A() 对象的锁定。如果然后另一个线程调用A.m()，它输入方法没有问题，因为它寻找的是锁定A.class 对象，而没有线程拥有这种锁。因此，即使您声明了方法synchronized，它实际上被两个不同的线程在同一时间访问。因此：永远不要使用对象引用来调用静态方法
在示例中 methodA 和 methodB 是实例方法（与静态方法相反）。将synchronized 放在实例方法上意味着线程必须在调用该方法的对象实例上获取锁（“内在锁”），然后线程才能开始执行该方法中的任何代码。
如果您有两个不同的实例方法标记为同步，并且不同的线程在同一个对象上同时调用这些方法，那么这些线程将竞争同一个锁。一旦一个线程获得锁，所有其他线程都将被该对象上的所有同步实例方法关闭。
为了让这两种方法同时运行，它们必须使用不同的锁，如下所示：
class A {
private final Object lockA = new Object();
private final Object lockB = new Object();
public void methodA() {
synchronized(lockA) {
//method A
}
}
public void methodB() {
synchronized(lockB) {
//method B
}
}
}
同步块语法允许指定执行线程需要获取内在锁定才能进入块的特定对象。
要理解的重要一点是，即使我们在单个方法上放置了“同步”关键字，核心概念是幕后的内在锁。
the Java tutorial 是这样描述这种关系的：
同步是围绕称为内部锁或监视器锁的内部实体构建的。 （API 规范通常将此实体简称为“监视器”。）内在锁在同步的两个方面都发挥作用：强制对对象状态的独占访问和建立对可见性至关重要的先发生关系。
每个对象都有一个与之关联的内在锁。按照惯例，需要对对象字段进行排他和一致访问的线程必须在访问对象之前获取对象的内在锁，然后在完成访问时释放内在锁。在获得锁和释放锁之间，线程被称为拥有内在锁。只要一个线程拥有一个内在锁，其他线程就不能获得相同的锁。其他线程在尝试获取锁时会阻塞。
锁定的目的是保护共享数据。仅当每个锁保护不同的数据成员时，您才可以使用上面示例代码中所示的单独锁。
【讨论】：
static synchronized 或 synchronized (A.class) 之类的方式获取类对象上的锁定
Java线程在进入实例同步java方法并获取类级锁对象级锁 /strong> 进入静态同步java方法时。
在您的情况下，方法（实例）属于同一类。因此，当一个线程进入 java 同步方法或阻塞时，它会获取一个锁（调用该方法的对象）。所以在第一个方法完成并释放lock(on object)之前，不能在同一个对象上同时调用其他方法。
【讨论】：
private final Object lock = new object(); with synchronized 来允许只有一个线程能够执行其中一种方法吗？谢谢
在您的情况下，您在同一个类实例上同步了两个方法。所以，这两个方法不能同时运行在同一个A类实例的不同线程上，但是可以运行在不同的A类实例上。
class A {
public synchronized void methodA() {
//method A
}
}
等同于：
class A {
public void methodA() {
synchronized(this){
// code of method A
}
}
}
【讨论】：
private final Object lock = new Object();，现在在两种方法中将lock 与同步块一起使用，那么您的说法是否成立？ IMO 因为 Object 是所有对象的父类，所以即使线程在类的不同实例上，一次也只有一个可以访问同步块内的代码。谢谢。
把你的代码想象成下面这样：
class A {
public void methodA() {
synchronized(this){
//method A body
}
}
public void methodB() {
synchronized(this){
// method B body
}
}
所以，方法级别的同步只是意味着同步（this）。 如果任何线程运行了这个类的方法，它会在开始执行之前获得锁，并持有它直到方法执行完成。
但是我可以在 methodA() 还在的时候在不同的线程上运行 methodB() 跑步？ （同一个对象）
确实不可能！
因此，多个线程将无法同时在同一个对象上运行任意数量的同步方法。
【讨论】：
为了清楚起见，静态同步和非静态同步方法可能同时或并发运行，因为一个具有对象级锁和其他类级锁。
【讨论】：
同步的 key 想法不容易陷入，它只有在 same object 实例上调用方法时才会生效 - 它已经被突出显示在答案和 cmets -
下面的示例程序是为了清楚地指出相同的 -
public class Test {
public synchronized void methodA(String currentObjectName) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodA in");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodA out");
}
public synchronized void methodB(String currentObjectName) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodB in");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodB out");
}
public static void main(String[] args){
Test object1 = new Test();
Test object2 = new Test();
//passing object instances to the runnable to make calls later
TestRunner runner = new TestRunner(object1,object2);
// you need to start atleast two threads to properly see the behaviour
Thread thread1 = new Thread(runner);
thread1.start();
Thread thread2 = new Thread(runner);
thread2.start();
}
}
class TestRunner implements Runnable {
Test object1;
Test object2;
public TestRunner(Test h1,Test h2) {
this.object1 = h1;
this.object2 = h2;
}
@Override
public void run() {
synchronizedEffectiveAsMethodsCalledOnSameObject(object1);
//noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects(object1,object2);
}
// this method calls the method A and B with same object instance object1 hence simultaneous NOT possible
private void synchronizedEffectiveAsMethodsCalledOnSameObject(Test object1) {
try {
object1.methodA("object1");
object1.methodB("object1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// this method calls the method A and B with different object instances object1 and object2 hence simultaneous IS possible
private void noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects(Test object1,Test object2) {
try {
object1.methodA("object1");
object2.methodB("object2");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
如果在不同的对象实例上调用方法，请注意按预期允许同时访问的输出差异。
输出 noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects() commented - 输出的顺序是 methodA in > methodA Out .. methodB in > methodB Out
和输出与 synchronizedEffectiveAsMethodsCalledOnSameObject() 评论 - 输出显示在突出显示的部分中 Thread1 和 Thread0 同时访问 methodA -
增加线程数会使其更加明显。
【讨论】：
不，这是不可能的，如果有可能，那么两种方法都可能同时更新同一个变量，这很容易损坏数据。
【讨论】：
您是在对象上而不是在类上同步它。所以它们不能同时在同一个对象上运行
【讨论】：
是的，它们可以同时运行两个线程。如果您创建该类的 2 个对象，因为每个对象仅包含一个锁，并且每个同步方法都需要锁。 因此，如果您想同时运行，请创建两个对象，然后尝试使用这些对象引用来运行。
【讨论】：
两个不同的线程在同一个对象上执行一个共同的同步方法，由于对象是相同的，当一个线程使用同步方法时，它必须验证锁，如果启用了锁，这个线程会去等待状态，如果锁被禁用，那么它可以访问对象，当它访问时，它会启用锁并释放锁 只有当它的执行完成时。 当另一个线程到达时，它将验证锁，因为它已启用，它将等待第一个线程完成执行并释放对象上的锁，一旦锁被释放，第二个线程将获得对该对象的访问权并且它将启用锁，直到它被执行。 所以执行不会不是并发的，两个线程会一个一个地执行，当两个线程对不同的对象使用同步方法时，它们会并发运行。
【讨论】：