Java 完成工作单元，直到发出停止信号

Question

我有一些 (Linux) C 代码正在转换为 Java。该代码有一个主循环，用于在每个循环顶部检查来自操作系统的 TERM 信号，否则会阻止信号。这样一来，它在循环中所做的每个“工作单元”都已完全完成（不会被中间的 TERM 信号中断）。

事实证明，这在 Java 中实现有点“有趣”。我想出了一些测试代码（如下），它似乎可以工作，但我不确定它是否会一直有效，或者我是否只是在测试中“幸运”。

所以，这是我的问题：这是好的代码还是只是偶尔会工作的代码？

TL;DR：工作线程和关闭线程调用一个通用的同步方法

public class TestShutdownHook {
    static int             a    = 0;       /* should end up 0 */
    static volatile int    b    = 0;       /* exit together */
    static boolean         go   = true;    /* signaled to stop */

    /*
     * this simulates a process that we want to do completely
     * or not at all.
     */
    private static void doitall () {
        System.out.println("start");
        ++a;                        /* simulates half the unit of work */
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("exception");  /* doesn't seem to happen */
        }   
        System.out.println("end");
        --a;                        /* the other half */
    }

    /*
     * there can be only one
     */
    private static synchronized void syncit (String msg) {
        if (msg.equals("exit")) go = false;
        if (go) doitall();
    }

    /*
     * starts a thread to wait for a shutdown signal,
     * then goes into the 'while go doit' loop
     */
    public static void main(String[] args) throws InterruptedException {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                int n = 0;  
                System.out.println("Shutdown coming...");
                syncit("exit");  /* can't happen while main is in syncit?  */
                System.out.println("Shutdown hook! " + a);

                /* this isn't really needed, just lets us see "goodbye" */
                while (b == 0) ++n;
                System.out.println("adios..."+n);
            }       
        }); 
        while (go) {
            syncit("loop");
            // there needs to be something else in this loop
            // otherwise, we will starve the shutdown thread.
            // either of the two lines below seem sufficient
            System.out.println("ok");
            Thread.sleep(1);
        }   
        System.out.println("goodbye");
        b = 1;
    }
}

Answer 1

只要在您期望的所有情况下运行（并完成）关闭挂钩，它就一定没问题。根据Jarrod Roberson here，它似乎与 SIGTERM 一样正常工作。如果您不需要使用信号处理程序显式捕获操作系统信号，我认为您无需担心。

Answer 2

所有可用的证据都表明，如果你已经注册了一个ShutdownHook，那么它将在一个TERM或INT信号被传递到JVM时启动并且所有其他线程都将被单独处理 直到 ShutdownHook 的 run() 方法退出（此时任何仍在运行的将被终止）。

因此，这导致了一个避免同步的更简单的解决方案：

public class AnotherTestShutdownHook {
    static int        a          = 0;           /* should end up 0 */
    static boolean    go         = true;        /* signaled to stop */
    static Thread     mainThread = Thread.currentThread();

    private static void trySleep ( int msecs ) {
        try { Thread.sleep(msecs); } catch (InterruptedException e) {}
    }

    private static void tryJoin ( Thread t ) {
        try { t.join(); } catch (InterruptedException e) {}
    }

    /*
     * this simulates a process that we want to do completely
     * or not at all.
     */
    private static void doitall () {
        System.out.println("start");
        ++a;
        trySleep(5000);
        System.out.println("end");
        --a;
    }

    /*
     * starts a thread to wait for a shutdown signal,
     * then does units of work until told to stop
     */
    public static void main(String[] args) {  
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                System.out.println("Shutdown coming...");
                go = false; 
                tryJoin(mainThread);        // wait for mainThread to exit
                System.out.println("Shutdown hook! " + a);
            }       
        }); 
        while (go) {
            doitall();
        }   
        System.out.println("goodbye");
    }
}