有三种不同的场景 https://stackoverflow.com/questions/40825747/close-my-program-before-windows-shutdown当您可以处理关闭和注销事件时。我将重点关注 Windows 应用程序，因为它也适用于控制台应用程序，如果由于某种原因您的应用程序导入 User32 函数，那么控制台句柄将不起作用。
基本上你需要两个函数：
ATOM RegisterClassEx(WNDCLASSEX *lpwcx);
注册类Ex https://msdn.microsoft.com/en-us/library/windows/desktop/ms633587(v=vs.85).aspx创建一种带有与之关联的钩子（即我们的关闭/注销处理程序）的新型窗口。
HWND WINAPI CreateWindowEx(
int dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName,
int dwStyle, int x, int y, int nWidth, int nHeight,
HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam
);
创建窗口Ex https://msdn.microsoft.com/en-us/library/windows/desktop/ms632680(v=vs.85).aspx实例化一个新窗口，该窗口有一个关联的事件钩子（通过注册的类），这样Windows将通知关联的钩子所有可能发生的事件 https://msdn.microsoft.com/en-us/library/windows/desktop/ms644927.aspx#system_defined.
这是一个完整的工作示例，只需启动它并注销或关闭计算机，重新启动后，看看%userprofile%\shutdown-hook.log文件它必须通过记录类似的内容来处理这些事件
...
action=proc-callback, event=22
...
code https://github.com/mageddo/java-native-examples/blob/7ffee35/src/main/java/nativeapi/jna/windows/shutdownhook/Main.java
public class Main {
/**
* <pre>
* Steps:
*
* 1. Create a WinProc (this function will handle all events)
* 2. Create a window class using the created WinProc
* 3. Create a window using the created window class
* 4. Use the WinProc to handle shutdown events
* </pre>
*/
public static void main(String[] args) {
// registering a window - https://msdn.microsoft.com/pt-br/library/windows/desktop/ms633587
// https://msdn.microsoft.com/pt-br/library/windows/desktop/ms633577
// typedef struct tagWNDCLASSEX {
// UINT cbSize;
// UINT style;
// WNDPROC lpfnWndProc;
// int cbClsExtra;
// int cbWndExtra;
// HINSTANCE hInstance;
// HICON hIcon;
// HCURSOR hCursor;
// HBRUSH hbrBackground;
// LPCTSTR lpszMenuName;
// LPCTSTR lpszClassName;
// HICON hIconSm;
// } WNDCLASSEX, *PWNDCLASSEX;
//
// ATOM WINAPI RegisterClassEx(
// _In_ const WNDCLASSEX *lpwcx
// );
final WinUser.WNDCLASSEX clazz = new WinUser.WNDCLASSEX();
clazz.lpszClassName = "MyCustomWindow";
clazz.cbSize = Native.getNativeSize(WinUser.WNDCLASSEX.class, null);
clazz.lpfnWndProc = new MyWinProc();
WinDef.ATOM classInst = User32.INSTANCE.RegisterClassEx(clazz);
System.out.printf("action=registerclass, clazz=%s, error=%d\n", classInst, Native.getLastError());
WinDef.HWND w = User32.INSTANCE.CreateWindowEx(
512, clazz.lpszClassName, "My Window",
WinUser.WS_OVERLAPPEDWINDOW, -2147483648, -2147483648, 250, 100,
null, null, null, null
);
System.out.printf("action=createWindow, w=%s, error=%d\n", w, Native.getLastError());
WinUser.MSG msg = new WinUser.MSG();
while (User32.INSTANCE.GetMessage(msg, null, 0, 0)) {
User32.INSTANCE.DispatchMessage(msg);
}
}
public interface User32 extends Library {
User32 INSTANCE = Native.loadLibrary("User32", User32.class, W32APIOptions.UNICODE_OPTIONS);
// ATOM WINAPI RegisterClassEx(
// _In_ const WNDCLASSEX *lpwcx
// );
WinDef.ATOM RegisterClassEx(WinUser.WNDCLASSEX lpwcx);
// HWND WINAPI CreateWindowEx(
// _In_ DWORD dwExStyle,
// _In_opt_ LPCTSTR lpClassName,
// _In_opt_ LPCTSTR lpWindowName,
// _In_ DWORD dwStyle,
// _In_ int x,
// _In_ int y,
// _In_ int nWidth,
// _In_ int nHeight,
// _In_opt_ HWND hWndParent,
// _In_opt_ HMENU hMenu,
// _In_opt_ HINSTANCE hInstance,
// _In_opt_ LPVOID lpParam
// );
WinDef.HWND CreateWindowEx(
int dwExStyle,
String lpClassName,
String lpWindowName,
int dwStyle,
int x,
int y,
int nWidth,
int nHeight,
WinDef.HWND hWndParent,
WinDef.HMENU hMenu,
WinDef.HINSTANCE hInstance,
WinDef.LPVOID lpParam
);
// BOOL WINAPI GetMessage(
// _Out_ LPMSG lpMsg,
// _In_opt_ HWND hWnd,
// _In_ UINT wMsgFilterMin,
// _In_ UINT wMsgFilterMax
// );
boolean GetMessage(WinUser.MSG lpMsg, WinDef.HWND hWnd, int wMsgFilterMin, int wMsgFilterMax);
// LRESULT WINAPI DispatchMessage(
// _In_ const MSG *lpmsg
// );
WinDef.LRESULT DispatchMessage(WinUser.MSG lpmsg);
WinDef.LRESULT DefWindowProc(WinDef.HWND hWnd, int uMsg, WinDef.WPARAM wParam, WinDef.LPARAM lParam);
}
/**
* <pre>
* All Possible events -
* https://msdn.microsoft.com/en-us/library/windows/desktop/ms644927.aspx#system_defined
* https://github.com/tpn/winsdk-10/blob/master/Include/10.0.10240.0/um/WinUser.h
* </pre>
*/
public static class MyWinProc implements WinUser.WindowProc {
private final OutputStream out;
public MyWinProc() {
try {
// this is unsafe because this file will never be closed, anyway it is just for a example
out = new FileOutputStream(new File(System.getProperty("user.home") + File.separator + "shutdown-hook.log"));
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public WinDef.LRESULT callback(WinDef.HWND hWnd, int uMsg, WinDef.WPARAM wParam, WinDef.LPARAM lParam) {
final String msg = String.format("action=proc-callback, event=%d %n", uMsg);
System.out.print(msg);
try {
out.write(msg.getBytes());
switch (uMsg){
case 0x0016:
out.write("shutdown".getBytes());
break;
case 0x0011:
out.write("logoff".getBytes());
break;
}
out.flush();
} catch (IOException e) {
throw new RuntimeException(e);
}
return User32.INSTANCE.DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
}
obs：只是一个建议，根据您的要求，我认为如果您只是启动一个后台线程，并且一次又一次地执行您必须执行的任务，那么也许会更有意义，因为如果 Windows 获得蓝屏死机 https://en.wikipedia.org/wiki/Blue_Screen_of_Death或者电源消失或者有人刚刚拔掉电源，那么 Windows 事件将无法帮助您。无论如何，后台线程解决方案相当简单。
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) {
Executors.newSingleThreadExecutor().execute(() -> {
while(!Thread.currentThread().isInterrupted()){
System.out.println("do a background stuff");
try {
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {/*I will look at that in the while clause*/}
}
});
System.out.println("doing another stuff");
}
}
我的依赖
compile group: 'net.java.dev.jna', name: 'jna', version: '4.5.0'
compile group: 'net.java.dev.jna', name: 'jna-platform', version: '4.5.0'
