Java 中的并发：同步静态方法

发布于 2024-10-26 12:25:41 字数 594 浏览 1 评论 0原文

我想了解 Java 中静态方法的锁定是如何完成的。

假设我有以下类：据

class Foo {
    private static int bar = 0;
    public static synchronized void inc() { bar++; }
    public synchronized int get() { return bar; }

我所知，当我调用 f.get() 时，线程获取对象 f 上的锁，当我执行 >Foo.inc() 线程获取类 Foo 上的锁。

我的问题是这两个调用如何相互同步？调用静态方法是否也会获取所有实例化的锁，或者相反（这似乎更合理）？

编辑：

我的问题不是静态同步如何工作，而是静态和非静态方法如何相互同步。即，我不希望两个线程同时调用 f.get() 和 Foo.inc()，但这些方法获取不同的锁。我的问题是如何防止这种情况以及在上面的代码中是否可以防止这种情况。

原文

I want to understand how locking is done on static methods in Java.

let's say I have the following class:

class Foo {
    private static int bar = 0;
    public static synchronized void inc() { bar++; }
    public synchronized int get() { return bar; }

It's my understanding that when I call f.get(), the thread acquires the lock on the object f and when I do Foo.inc() the thread acquires the lock on the class Foo.

My question is how are the two calls synchronized in respect to each other?
Is calling a static method also acquires a lock on all instantiations, or the other way around (which seems more reasonable)?

EDIT:

My question isn't exactly how static synchronized works, but how does static and non-static methods are synchronized with each other.
i.e., I don't want two threads to simultaneously call both f.get() and Foo.inc(), but these methods acquire different locks. My question is how is this preventable and is it prevented in the above code.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

橘虞初梦 2024-11-02 12:25:41

静态和实例 synchronized 方法彼此不相关，因此您需要在它们之间应用一些额外的同步，如下所示：（

class Foo {
    private static int bar = 0;
    public static synchronized void inc() { bar++; }
    public synchronized int get() { 
        synchronized (Foo.class) { // Synchronizes with static synchronized methods
            return bar; 
        }
    }
}

尽管在本例中将 synchronized 保留在 get() 没有意义，因为它不执行任何需要实例同步的操作）。

注意死锁 - 由于此代码获取多个锁，因此它应该以一致的顺序执行，即其他同步静态方法不应尝试获取实例锁。

另请注意，使用原子字段可以在根本不同步的情况下解决此特定任务：

class Foo {
    private static AtomicInteger bar = new AtomicInteger(0);
    public static void inc() { bar.getAndIncrement(); }
    public int get() { return bar.get(); }
}

Static and instance synchronized methods are not related to each other, therefore you need to apply some additional synchronization between them, like this:

class Foo {
    private static int bar = 0;
    public static synchronized void inc() { bar++; }
    public synchronized int get() { 
        synchronized (Foo.class) { // Synchronizes with static synchronized methods
            return bar; 
        }
    }
}

(though in this case leaving synchronized on get() doesn't make sense, since it doesn't do anything that requires synchronization on instance).

Beware of deadlocks - since this code aquires multiple locks, it should do it in consistent order, i.e. other synchronized static methods shouldn't try to acquire instance locks.

Also note that this particular task can be solved without synchronization at all, using atomic fields:

class Foo {
    private static AtomicInteger bar = new AtomicInteger(0);
    public static void inc() { bar.getAndIncrement(); }
    public int get() { return bar.get(); }
}

回复收藏 0 原文

凶凌 2024-11-02 12:25:41

同步静态方法实际上相当于：

public static void foo() {
    synchronized (ClassName.class) {
        // Body
    }
}

换句话说，它锁定与声明该方法的类关联的 Class 对象。

来自 JLS 的第 8.4.3.6 节：

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

A synchronized static method is effectively equivalent to:

public static void foo() {
    synchronized (ClassName.class) {
        // Body
    }
}

In other words, it locks on the Class object associated with the class declaring the method.

From section 8.4.3.6 of the JLS:

A synchronized method acquires a monitor (§17.1) before it executes. For a class (static) method, the monitor associated with the Class object for the method's class is used. For an instance method, the monitor associated with this (the object for which the method was invoked) is used.

回复收藏 0 原文