Richard Pajerski  Software development and consulting

Ask the Architects - JavaOne 2026

Java Virtual Threads (https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html) have been directly available to Notes/Domino developers since HCL began shipping Java 21 (or more accurately OpenJ9) with release 14.5 in June 2025. But when should we use virtual threads? In theory, any Notes/Domino Java workload that currently depends on platform threads could benefit (at least in efficiency) by moving to virtual threads.

Measuring efficiency can be complex and case-specific so deciding to use one thread type over the other is something that has to be tested. But some basic tests demonstrate that virtual threads "complete" much more quickly than platform threads and more noticeably so as concurrent threads climb into the thousands.

Our two test programs are nearly identical.

Platform threads

Virtual threads

The key lines are:

Platform threads:

Thread thread = new Thread(new Runnable() {

Virtual threads:

Thread thread = Thread.ofVirtual().start(new Runnable() {

Fedora Linux 43 workstation:

(in this case, the speed differences between operating systems are primarily due to different hardware)
 
For even higher numbers of concurrent threads, the situation gets proportionally worse; here are the results for one million threads (both on Windows):

Platform:
Task 1000000 completed in 27465ms

Virtual:
Task 1000000 completed in 1454ms

So we go from around a 1.4x improvement with 2,000 virtual threads to close to a 20x improvement with 1M threads.

These tests don't perform any useful work (and are obviously not specifically tied to Notes/Domino) but the differences alone suggest that virtual threads will outperform platform threads once they have real work to do.  There are a number of reasons for virtual threads' improved performance but the amount of system resources per platform thread and the removal of OS-level context switching are probably the most consequential.  A good summary of the motivations and goals for introducing virtual threads into the OpenJDK can be found here and here.

And while they were on their way, all at once Jesus met them and said, All hail. With that, they came near to him, and clung to his feet, and worshipped him.  Then Jesus said to them, Do not be afraid; go and give word to my brethren to remove into Galilee; they shall see me there.  (St. Matthew 28: 9-10; Knox Version).

Apparition de Jésus aux saintes femmes (Jesus appears to the Holy Women), James Tissot (Public domain)

Download:

Notes and Domino 14.5.1 are now available on the My HCLSoftware portal.

Release Notes:

https://support.hcl-software.com/csm?id=kb_article&sysparm_article=KB0129261

Developer Documentation:

https://help.hcl-software.com/dom_designer/14.5.1/index.html

Administrator Documentation:

https://help.hcl-software.com/domino/14.5.1/admin/index.html

Ecce virgo in utero habebit, et pariet filium: et vocabunt nomen ejus Emmanuel, quod est interpretatum Nobiscum Deus.
(Matthew 1:23; Latin Vulgate).

Image (public domain): Birth of Christ by Ernst Deger

Then Jesus said, Do not cling to me thus; I have not yet gone up to my Father's side.  Return to my brethren, and tell them this; I am going up to him who is my Father and your Father, who is my God and your God.  (St. John 20: 17; Knox Version).

Noli me tangere (Touch me not), James Tissot (Public domain)

Et Verbum caro factum est, et habitavit in nobis: et vidimus gloriam ejus, gloriam quasi unigeniti a Patre, plenum gratiæ et veritatis.  (St. John 1: 14).

Image (public domain): La nativité de Notre-Seigneur Jésus-Christ, James Tissot

I'm currently reviewing LS2J as an alternative for replacing a number of custom Notes applets I've deployed over the years.  The applets have been very reliable and effective in areas where Notes is typically not that strong such as displaying and editing tabular data.  But with applets' deprecation in Java and their "broken" status in Notes 64-bit versions, I need a viable transition to something that can preserve the existing functionality/investment as much as possible.

Although I don't see any obvious way to embed top-level Java windows (JFrame, JDialog) in the same manner as applets (which can be placed on a form like most other widgets), with LS2J I've found I can call them from behind a simple button and in the case of JDialog, even block the Notes client without breaking things too badly.  I can also call a JFrame from LS2J but the window can quickly lose focus -- in the same way it does when called from a Java agent.  I believe this is due to it being launched on a separate thread.

Below is a contrived example with JDialog but so far so good;  I'm able to replace a form-based applet with a simple button that calls a JDialog, blocks for user input and then transfers the text back to Notes:

This is actually simpler than applets which require Javascript when transferring to/from Notes UI documents (not pleasant).

Our button code (Options):

Click function:

And our associated Script Library:

The JDialog class is a bit more involved but not important in the context of this post.  The important part consists of returning the contents of a JTextArea when "OK" is clicked:

public String getFieldData() {
    return jTextArea1.getText();
 }

And that's it!

Fixpack 1 for both Notes 14 client and Domino 14 server are now available: https://my.hcltechsw.com/downloads

Release notes: https://support.hcltechsw.com/csm?id=kb_article&sysparm_article=KB0112431

And they went into the tomb, and saw there, on the right, a young man seated, wearing a white robe; and they were dismayed.  But he said to them, No need to be dismayed; you have come to look for Jesus of Nazareth, who was crucified; he has risen again, he is not here. Here is the place where they laid him.  (St. Mark 16: 5-6; Knox Version).

Resurrection of Christ, Fra Angelico (Public domain)

The time is accomplished, and the kingdom of God is at hand: repent, and believe the gospel.  (St. Mark 1:15; Douay-Rheims version).

Image (public domain): The Nativity with the Prophets Isaiah and Ezekiel, Duccio di Buoninsegna.  Courtesy National Gallery of Art, Washington.

As I mentioned previously, having Java 17 available with the latest release of Notes/Domino has brought welcome changes for Java developers.  Just to scratch the surface a bit, here are three language-level niceties that we can immediately benefit from:

1.  Simplified access to file contents
2.  Local-variable type inference (var identifier)
3.  Text blocks

1.  Simplified access to file contents
Java has been (in)famous for offering a number of ways to open/read and write/close files.  As of Java 11, perhaps the simplest way to get text out of a file is:

Files.readString(Path p);

A two-liner in a local Java agent on a Windows 11 client:

Javadoc:  https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/nio/file/Files.html#readString(java.nio.file.Path)

2.  Local-variable type inference (var identifier)

The var type identifier has been available since Java 10 and is intended to help reduce "boilerplate" code:

import lotus.domino.*;

public class JavaAgent extends AgentBase {

    public void NotesMain() {

      try {
         var s = getSession();
         var db = s.getCurrentDatabase();
         System.out.println("Db title: " + db.getTitle());

                /* Contrast:
                     Session s = getSession();
                     Database db = s.getCurrentDatabase();
                   */
      } catch(Exception e) {
          e.printStackTrace();
      }
   }
}

More: Using the Var Type Identifier

3.  Text blocks
In Java 15, Text Blocks were introduced.  In a more developed application, it's probably a better idea to store strings and text outside of source code, especially if they need to be regularly modified.  But using text blocks can be a time saver for quick testing, demos, etc. and provide improved source readability.

import lotus.domino.*;

public class JavaAgent extends AgentBase {

    public void NotesMain() {

      try {
         var textBlock = """

                Using text blocks in Java source

                code simplifies text formatting

                and improves readability!

                """;

         System.out.println(textBlock);

      } catch(Exception e) {
          e.printStackTrace();
      }
   }
}

Note: To use these features, remember to adjust your compiler levels appropriately:

Notes 14 is now GA and an improved listing of the Notes "Additional options" (File > Preferences > Basic Notes Client Configuration) is an unexpected but very welcome feature!

Previously, all options were in one long list and so the context where each one applied was not always clear.  Now a categorical description precedes each option entry:

Nice touch, HCL and thank you!

Those who have been programming with Java in Notes/Domino over the years will be pleased to learn of the move from Java 8.x to Java 17 which is planned for the next release of ND 14 at the end of the year.  The version gap is rather stark and indeed a lot has changed.  One nice summary of the changes between the two version can be found at The Java Almanac here:  https://javaalmanac.io/jdk/17/apidiff/8/.

I've yet to explore the impact to the ND world in any detail but will try to cover that in some future posts.  A particular area of interest for me that's still "unresolved" is how HCL intends to treat Java applets.  Here I mean applets embedded in Notes client applications, not for use in web browsers.  Applets were deprecated for removal in Java 17 and of course have long been out of use in web browsers.  But will HCL continue to support their use in the Notes client and if so, for how long?

And suddenly there was a great trembling of the earth, because an angel of the Lord came to the place, descending from heaven, and rolled away the stone and sat over it; his face shone like lightning, and his garments were white as snow; so that the guards trembled for fear of him, and were like dead men.  (Saint Luke 28:2-4 Knox Version).