《Java 并发编程·性能诊断与事故》9.2 安全发布失败的对象

public class EscapeTrial {

    static final class Service {
        static volatile Service registry;
        final int poolSize;                  // final
        int timeoutMs;                       // 非 final

        Service(boolean slowInit) {
            registry = this;                 // 构造器里注册：this 逸出
            if (slowInit) {
                try {
                    Thread.sleep(1);         // 模拟构造器中的耗时初始化
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            poolSize = 8;
            timeoutMs = 500;
        }
    }

    public static void main(String[] args) throws Exception {
        int trials = Integer.parseInt(args[0]);
        boolean slow = Boolean.parseBoolean(args[1]);

        java.util.concurrent.atomic.AtomicBoolean sawPartial =
                new java.util.concurrent.atomic.AtomicBoolean();
        java.util.concurrent.atomic.AtomicLong reads =
                new java.util.concurrent.atomic.AtomicLong();
        Thread observer = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                Service s = Service.registry;
                if (s != null) {
                    reads.incrementAndGet();
                    if (s.poolSize != 8 || s.timeoutMs != 500) {
                        sawPartial.set(true);
                    }
                }
            }
        }, "observer");
        observer.setDaemon(true);
        observer.start();

        int exposed = 0;
        for (int i = 0; i < trials; i++) {
            sawPartial.set(false);
            Service.registry = null;
            new Service(slow);
            if (sawPartial.get()) {
                exposed++;
            }
        }
        observer.interrupt();
        observer.join();
        System.out.println("trials=" + trials + " slowInit=" + slow
                + " exposedTrials=" + exposed + " observerReads=" + reads.get());
    }
}

trials=5000 slowInit=false exposedTrials=0 observerReads=1927
trials=2000 slowInit=true exposedTrials=2000 observerReads=410412171
trials=2000 slowInit=true exposedTrials=2000 observerReads=423130702

final class Service {

    private final int poolSize;
    private final int timeoutMs;

    Service(int poolSize, int timeoutMs) {   // 构造器只赋值，不发布
        this.poolSize = poolSize;
        this.timeoutMs = timeoutMs;
    }

    int poolSize() {
        return poolSize;
    }

    int timeoutMs() {
        return timeoutMs;
    }
}

public final class ServiceRegistry {

    private volatile Service current;        // 构造完成后再发布

    public void register(Service service) {
        current = service;
    }

    public Service current() {
        return current;
    }
}

import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.II_Result;

@JCStressTest
@Outcome(id = "0, 0", expect = Expect.ACCEPTABLE, desc = "发布会话尚未完成，读者没看到对象")
@Outcome(id = "1, 42", expect = Expect.ACCEPTABLE, desc = "读者看到完整初始化的对象")
@Outcome(id = "1, 0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "读者看到引用但字段仍是默认值")
@State
public class UnsafePubTest {

    static final class Config {
        int timeoutMs;              // 非 final

        Config(int timeoutMs) {
            this.timeoutMs = timeoutMs;
        }
    }

    Config config;                  // 非 volatile 发布

    @Actor
    public void publisher() {
        config = new Config(42);
    }

    @Actor
    public void consumer(II_Result r) {
        Config c = config;
        if (c != null) {
            r.r1 = 1;
            r.r2 = c.timeoutMs;
        }
    }
}

import org.openjdk.jcstress.annotations.*;
import org.openjdk.jcstress.infra.results.III_Result;

@JCStressTest
@Outcome(id = "0, 0, 0", expect = Expect.ACCEPTABLE, desc = "读者尚未看到注册的回调")
@Outcome(id = "1, 3, 500", expect = Expect.ACCEPTABLE, desc = "读者看到完全初始化的回调")
@Outcome(expect = Expect.ACCEPTABLE_INTERESTING, desc = "其他中间状态（字段仍是默认值）")
@State
public class ThisEscapeTest {

    static final class Handler {
        final int maxRetries;       // final，但在 this 逸出之后才赋值
        int timeoutMs;              // 非 final

        Handler(ThisEscapeTest owner) {
            owner.handler = this;   // 构造器里注册：this 逸出
            maxRetries = 3;
            timeoutMs = 500;
        }
    }

    Handler handler;

    @Actor
    public void publisher() {
        new Handler(this);
    }

    @Actor
    public void consumer(III_Result r) {
        Handler h = handler;
        if (h != null) {
            r.r1 = 1;
            r.r2 = h.maxRetries;
            r.r3 = h.timeoutMs;
        }
    }
}

mvn -q -DskipTests package
mvn -q dependency:build-classpath -Dmdep.outputFile=cp.txt
CP="target/classes:$(cat cp.txt)"
java -cp "$CP" org.openjdk.jcstress.Main -m quick -c 8 -v \
  -t 'UnsafePubTest|FinalPubTest|SafePubTest|ThisEscapeTest'

    RESULT      SAMPLES     FREQ       EXPECT  DESCRIPTION
    0, 0, 0  184,525,357   72.78%   Acceptable  读者尚未看到注册的回调
    1, 0, 0        5,678   <0.01%  Interesting  其他中间状态（字段仍是默认值）
  1, 0, 500          918   <0.01%  Interesting  其他中间状态（字段仍是默认值）
    1, 3, 0        1,177   <0.01%  Interesting  其他中间状态（字段仍是默认值）
  1, 3, 500   69,001,344   27.22%   Acceptable  读者看到完全初始化的回调

import java.util.function.Consumer;

public final class NotificationDispatcher {

    public interface Registry {
        void register(NotificationDispatcher dispatcher);
    }

    private final Consumer<String> mail;
    private final Consumer<String> sms;
    private final Consumer<String> push;

    public NotificationDispatcher(Consumer<String> mail,
                                  Consumer<String> sms,
                                  Consumer<String> push) {
        this.mail = mail;
        this.sms = sms;
        this.push = push;
    }

    public void start(Registry registry) {
        registry.register(this);             // 构造完成之后才发布
    }
}