java - 从另一个线程初始化同一类的静态字段时访问静态方法

Question

我遇到了一个非常奇怪的问题，除了将问题分成两类之外我无法解决。

我想知道是否有一个不拆分类的解决方案，更重要的是想知道是否有人知道为什么 Java 引擎决定这样做。

问题:我有一个带有静态方法、静态字段和构造函数的类。静态字段被初始化为类本身的实例。在实例初始化期间，我想访问上述静态方法。请参阅以下代码:

public class Simple {
    public Simple() {
        int count = 4;

        for (int i = 0; i < count; i++) {
            System.out.println("Simple: " + Simple.isFlag()); 
        }

    }

    private static Simple i = new Simple();

    public static boolean isFlag() {
        return true;
    }

    public static void run() {

    }
}

public class Main {

    public static void main(String[] args) {
        Simple.run();
    }

}

这段代码运行得非常好。输出如下所示:

Simple: true
Simple: true
Simple: true
Simple: true

输出是在我调用 run() 方法后生成的，因为 stiv 字段 i 仅在我访问该类的第一个静态成员后才初始化。

我现在想要做完全相同的事情，除了多线程。请参阅此处:

public class Parallel {
    public Parallel() {
        int count = 4;

        CountDownLatch latch = new CountDownLatch(4);
        for (int i = 0; i < count; i++) {
            Thread t = new Thread(() -> {
                System.out.println("Parallel: " + Parallel.isFlag());
                latch.countDown();

                Thread.currentThread().interrupt();
            });

            t.start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    private static Parallel i = new Parallel();

    public static boolean isFlag() {
        return true;
    }

    public static void run() {

    }
}

public class Main {

    public static void main(String[] args) {
        Parallel.run();
    }

}

这什么也不返回。主线程卡在 latch.await(); 处，而其他线程卡在 Parallel.isFlag() 处。编辑:如下面 Jaims 所示，线程根本不启动。

这对我来说没有任何意义。为什么这不起作用，但第一种情况却有效？本质上他们也在做同样的事情。

我想知道 Java 引擎如何决定何时等待、何时不等待。可以在代码中的某个地方更改它吗？

此外，这与 CountDownLatch 无关，而仅与多线程有关。看看这个最终示例:

public class NonParallel {
    public NonParallel() {
        int count = 4;

        CountDownLatch latch = new CountDownLatch(4);
        for (int i = 0; i < count; i++) {
            System.out.println("NonParallel: " + NonParallel.isFlag());
            latch.countDown();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private static NonParallel i = new NonParallel();

    public static boolean isFlag() {
        return true;
    }

    public static void run() {

    }
}

public class Main {

    public static void main(String[] args) {
        NonParallel.run();
    }

}

这很好用。输出如下:

NonParallel: true
NonParallel: true
NonParallel: true
NonParallel: true

---

编辑:当对象初始化不是类初始化的一部分时，这些都不适用。这纯粹是关于类初始化，只有在使用本问题中描述的静态对象时才会发生。请参阅此处:

public class NonStaticParallel {
    public NonStaticParallel() {
        int count = 4;

        CountDownLatch latch = new CountDownLatch(4);
        for (int i = 0; i < count; i++) {
            Thread t = new Thread(() -> {
                System.out.println("NonStaticParallel: " + isFlag());
                latch.countDown();

            });

            t.start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


    public  static  boolean isFlag() {
        return true;
    }

    public static void run() {
        new NonStaticParallel();
    }

}

这个工作没有任何问题:

Parallel: true
Parallel: true
Parallel: true
Parallel: true

---

答案:

Andreas 解释了正在发生的事情。

Jaims 是对的，线程根本就没有启动。发生这种情况可能是因为它们需要初始化类，因此它们立即被阻止。 (如果我们使用自己的类中的可运行对象而不是 lambda 或匿名内部类，那么它们会正常运行，除非它们访问正在初始化的类的任何静态成员)

Yoshi 提供了规范的链接和摘录，因此被标记为正确答案，因为这就是我想要的。

Answer 1

我尝试了你的代码并做了两件事:

1. 首先，我将 lambda 设为 Parallel 的静态内部类……以防万一；这并没有改变任何东西。
2. 既然您评论说线程卡在 Parallel.isFlag() 上，我尝试用 true 替换调用...并且成功了!

所以，我做了一些研究，发现了这个，这听起来像是对正在发生的事情的一个有希望的解释:http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4.2

具体来说这部分:

For each class or interface C, there is a unique initialization lock LC. The mapping from C to LC is left to the discretion of the Java Virtual Machine implementation. The procedure for initializing C is then as follows:

1. Synchronize on the initialization lock, LC, for C. This involves waiting until the current thread can acquire LC.

2. If the Class object for C indicates that initialization is in progress for C by some other thread, then release LC and block the current thread until informed that the in-progress initialization has completed, at which time repeat this step.

(强调。)因此，这将表明以下内容:

1. 主线程在评估private static Parallel i = new Parallel();时开始类初始化并启动线程。然后它等待latch.await()。 Parallel 的类对象应指示初始化“正在进行”。
2. 启动的线程还会尝试引用Parallel 的静态成员。每个线程看到初始化正在进行中，并决定等待，直到主线程(现在正在等待线程对锁存器进行倒计时)完成。显然这是一个僵局。