在java中使用synchronized block一次阻止对多个方法的访问

如果我有两种方法：

public class A {

    public void doSomething() {
        synchronized(A.class) {
            //synchronized block here
        }
    }

    public void doSomethingElse() {
        synchronized(A.class) {
           //synchronized block here
        }
    }
}

所以我的问题是，

A.class

是否像一个全局锁？这意味着一个线程执行方法

doSomething（）

会被阻塞，而另一个线程执行

doSomethingElse（）

---

谢谢。

它将获得对象锁，所有其他线程将被阻止，直到

当前线程释放锁为止。根据java规范：

同步方法在执行之前获取监视器（§17.1）。
对于类（静态）方法，与该类关联的监视器
使用方法类的对象。对于实例方法
与此关联的监视器（为其创建方法的对象）
调用）已使用

.
它获得对象锁，所有其他线程将被阻止，直到当前线程释放锁为止。根据java规范：

同步方法在执行之前获取监视器（§17.1）。
对于类（静态）方法，与该类关联的监视器
使用方法类的对象。对于实例方法
与此关联的监视器（为其创建方法的对象）
调用）已使用


类的行为像一个全局锁

任何
synchronized
块都会锁定特定对象。锁定
A.class
相当于对正在运行的
ClassLoader
的“全局”锁定，因为Java保证每个加载程序中只有一个
A.class
对象的实例
A.class
是一个对象，就像
newa（）
是一个对象一样

锁定
A.class
与锁定静态方法相同：

public class A {
    public static synchronized void someStaticMethod() {
        // in here you are locked on A.class as well
    }
    public void doSomething() {
        synchronized (A.class) {
            // this block is locked on the same object as someStaticMethod()
        }
    }
}

作为比较，当您锁定实例方法（与静态方法相反）时，它与锁定正在执行的
a
的实例相同。换句话说，
这个
：

public class A {
    public synchronized void someInstanceMethod() {
        // in here you are locked on the instance of A (this)
    }
    public void doSomething() {
        synchronized (this) {
            // this block is locked on the same instance of A
        }
    }
}

同样，它是关于特定对象的问题。这是我的建议

类的行为像一个全局锁

任何
synchronized
块都会锁定特定对象。锁定
A.class
相当于对正在运行的
ClassLoader
的“全局”锁定，因为Java保证每个加载程序中只有一个
A.class
对象的实例
A.class
是一个对象，就像
newa（）
是一个对象一样

锁定
A.class
与锁定静态方法相同：

public class A {
    public static synchronized void someStaticMethod() {
        // in here you are locked on A.class as well
    }
    public void doSomething() {
        synchronized (A.class) {
            // this block is locked on the same object as someStaticMethod()
        }
    }
}

作为比较，当您锁定实例方法（与静态方法相反）时，它与锁定正在执行的
a
的实例相同。换句话说，
这个
：

public class A {
    public synchronized void someInstanceMethod() {
        // in here you are locked on the instance of A (this)
    }
    public void doSomething() {
        synchronized (this) {
            // this block is locked on the same instance of A
        }
    }
}

同样，它是关于特定对象的问题。以下是。
您的示例将锁定所有方法中的线程，这些方法在同一类加载器加载的类的所有实例中获取锁，所以若任何一个线程获取锁，则阻止所有其他线程访问该对象或该类的任何其他对象上的任何方法。通常，设置这样的东西可能是个坏主意。锁将是不必要的粗粒度锁（导致线程等待，即使它们只想访问属于不存在共享的不同实例的数据），并且会过度限制并发性。若您有一个实际需要这个的设计，那个么您应该质疑您的设计。
您的示例将锁定所有方法中的线程，这些方法在同一个类加载器加载的类的所有实例中获取锁，因此，如果任何一个线程获得锁，该锁阻止所有其他线程访问该对象或该类的任何其他对象上的任何方法。通常，设置这样的东西可能是个坏主意。锁将是不必要的粗粒度锁（导致线程等待，即使它们只想访问属于不存在共享的不同实例的数据），并且会过度限制并发性。如果你有一个设计确实需要这个，你应该质疑你的设计。
是的-这正是它的意思！如果答案有帮助，提醒你接受。是的，这正是它的意思！提醒您接受答案（如果有帮助）。但是只有在
A.class
上同步的其他线程才会被阻止，对吗？更清楚地说，“直到当前线程释放锁”。。。不必这样做…但是只有在
A.class
上同步的其他线程才会被阻止，对吗？更清楚地说，“直到当前线程释放锁”。。。没必要这么做。。。