How are Promises implemented in Javascript without threads

I think that Roamer-1888's comment in reply to the OP may be the key to distilling the information in other answers into something simple to understand.

Think of it this way - promises do not provide asynchronism, but are a syntactic convenience for handling asynchronism provided by other means. - Roamer-1888

JS is single-threaded, but the environments JS is running in can take advantage of other threads. To use the browser as an example: JS has access to web APIs (fetch, for example) that allow it, via the browser engine, to perform work outside of the single-threaded JS environment, whether that be a network request, something handled by a web worker, whatever. Promises simply keep track of these operations and receive their results when they've finished.

The browser-written native code underneath the JavaScript layer tends to have threads implemented very neatly. As it turns out, that's usually all you need. Promises tend not to be needed for performing actual computation work in JavaScript (although workers make that easier) but for loading outside resources, and getting callbacks when they're done. JS Promises just assign callbacks to those functions like "image.onLoad" and check whether to notify another function.

Hogan may have summarized it best - event-based programming.

Promises were invented to help manage asynchronous operations. Promises themselves do not need threads in order to do that. They are objects that essentially provide bookkeeping for asynchronous operations - keeping state flags, result values and listeners for a state transition. These are all things that can easily be done with regular single threaded Javascript.

So, as long as you have asynchronous operations (however those operations are implemented), you can benefit from promises and don't need threads to implement them.

What it looks like you are seeing in your Java code is code that helps run regular tasks in a separate thread (to give synchronous operations some asynchronous-type behavior). That is not what promises do. So, if you already have asynchronous operations in your environment, you would not need this type of code in order to use promises.

Examples of asynchronous things in Javascript are pretty much anything that you register an interest in and the actual event occurs some time in the future and other code can run before that event fires. In a browser's Javascript environment, this includes things like setTimeout(), keyboard events, mouse events, ajax completion callbacks, etc... These are all asynchronous events. You register an interest in them (by registering an event listener or passing a callback to some function). Internal to the Javascript implementation, there are likely threads that are making these asynchronous events work, but those threads do not need to be exposed to the programmer directly for the asynchronous functionality to be there. For example, see this post for how Javascript manages to run ajax calls in the background while other Javascript things are running. All you need to know is that your callback function will be called some indeterminate time in the future.

So, in Javascript, promises are used to manage the asynchronous operations that are already present in your environment. They are not used to make non-async things become async (you would need threads in order to do that).

Keep in mind that promises themselves are just monitoring tools, used to monitor existing asynchronous operations. Promises are not actually asynchronous themselves except for .then() which can be implemented with a built-in API such as setTimeout() or setImmediate() or nextTick(). Promises do not need their own native code or threads. In fact, you can write a promise implementation in plain, single threaded Javascript if you want.