stoppable | Node 's ` server.close ` the way you expected it to work | Runtime Evironment library

I believe my com.my.package application is successully (and fully) terminated.

A lot more has happened than that. The "Force Stop" button is not the sort of thing that you want users doing.

how can I reach this programmatically, if those lines of my code above doesn't make this?

You cannot force-stop your own app.

why Android keeps my application in some quasi-running state if it explicitly asks for exit?

Quoting the documentation:

An unusual and fundamental feature of Android is that an application process's lifetime is not directly controlled by the application itself. Instead, it is determined by the system through a combination of the parts of the application that the system knows are running, how important these things are to the user, and how much overall memory is available in the system.

Having an "Exit" option in an Android app is very unusual. What you are presently doing isn't horrible as an implementation of "exit" logic, though users might get confused by having the app's task vanish.

As you point out, changes to service host grouping in Windows 10 may result in services of type SERVICE_WIN32_SHARE_PROCESS running in their own, isolated process. Whenever that happens to a service, SC will show it as SERVICE_WIN32 -- the confusing union of SERVICE_WIN32_OWN_PROCESS and SERVICE_WIN32_SHARE_PROCESS.

We've confirmed this situation by playing with the registry.

On our Windows 10 VM (which has ample RAM to trigger the process isolation enhancements), SC says AppInfo is of type WIN32 (30):

Task Manager reported that AppInfo was running in its own process.

As per the documentation, we disabled process isolation for the AppInfo service by adding the SvcHostSplitDisable value:

And after a reboot, SC reported AppInfo of type WIN32_SHARE_PROCESS (20):

The Task Manager confirmed that the process was indeed shared.

So its all down to those changes to service process isolation in Windows 10 Creators Update (version 1703).

The StoppableThread should be joined.

Because it is just a thin wrapper about threading.Thread giving you a possibility of setting and checking flag stopper.

In this case, there must be a code that regularly checks this flag. The amount of delay between checks depends on the user of the class. And given the fact that it is assumed that the thread should be correctly stopped, you must use join. Because if you make the thread as daemon and try to stop it before the application finishing:

Daemon threads are abruptly stopped at shutdown. Their resources (such as open files, database transactions, etc.) may not be released properly. If you want your threads to stop gracefully, make them non-daemonic and use a suitable signalling mechanism such as an Event.

1. A leak is possible only if your code is responsible for checking the stopper flag and subsequent exiting from the thread does not work correctly. Otherwise, there is no leaks, because the app, even join is not called, will wait for the completion of all non-daemon threads. But using join will give more control over the program flow.
2. Taking all of the above into consideration, i think that making StoppableThread as daemon is bad idea.

Your shared state is not protected from concurrent access consistently. For example take the isStopped field: