Multi-threaded JavaScripting Using the Nashorn JavaScript Engine
I have been writing JavaScript for enterprise applications for more than 20 years. From that statement, it’s easy to discern that I’ve been a JavaScript advocate for a long, long time. JavaScript is a truly unique language, sporting qualities found in both procedural and functional languages. Despite this, there has always been one glaring missing feature: the concept of multi-threading. Over the years, I’ve come up with a variety of workarounds to emulate threading, yet it was not until Java switched from the Rhino to the Nashorn compiler that truly multi-threaded processing in JavaScript became possible.
To that end, I’ve provided a couple examples of how to instantiate a thread in a JavaScript stage. You might want to use this for things like streaming queries, background logging or processing, and so on.
The Code:
function (doc) { logger.info("BEGIN THREAD TEST ****** "); try { // EXAMPLE 1 - Thread in Extended Runnable var Runnable = Java.type('java.lang.Runnable'); var Printer = Java.extend(Runnable, { run: function () { logger.info('printed from a separate thread'); } }); var Thread = Java.type('java.lang.Thread'); new Thread(new Printer()).start(); // EXAMPLE 2 - Thread Only new Thread(function () { logger.info('printed from another thread'); }).start(); } catch (err) { logger.error(err); } return doc; }
Breaking it down
So what is going on here? The above code actually starts two separate threads: one running in the context of an extended Runnable, and the other is a standalone thread. The snippets are relative short, so I don’t think we need to break out snippets. The long and the short of it is that you declare a mult-threading enabled class (anything that implements Runnable), pass a function to it as an argument, and start it.
Now, I realize that I’m letting my inner geek show here, but I really think this is wildly cool. You can now run functional logic within the scope of a procedural object. It really doesn’t get much cooler than that!
All that said, there are some serious caveats you need to consider:
- If you start your own thread, you’re responsible for stopping it. Make sure you factor this responsibility into your code.
- The numbers of threads allowed in the JVM is finite. You want to start (and stop) your threads explicitly, gracefully, and use them sparingly. Keep in mind that a custom process spinning up a large number of threads could potentially conflict with other processes in the pipeline.
- Don’t use a thread in your pipeline unless it is absolutely necessary.
So to summarize: Threading is now possible in JavaScript, and it’s pretty darn cool, but use it wisely.