UnboundID Server SDK

Working with Threads

In some cases, it may be desirable for an extension to create one or more threads to allow it to perform some processing in the background, or to perform multiple sets of processing concurrently. If your extension may need to create one or more threads for some reason, then there are a number of things to keep in mind.

In general, extensions should not directly create threads (e.g., by creating objects which extend java.lang.Thread, or by calling new Thread(Runnable)). Instead, the code to be invoked in that thread should be in a class that implements the ServerThread interface, and you should actually create the thread using the ServerContext.createThread method. This provides a number of benefits over other methods of creating threads, including:

• It requires that a name be provided for the thread when it is created. If a thread has a well-chosen name, then it can be very useful in helping to understand the purpose of that thread when debugging problems.
  
  
• Whenever a server thread is created, a stack trace is captured and stored in the thread. Having information about the context in which a thread was created may be very useful for debugging certain kinds of problems.
  
  
• Server threads will have additional processing performed whenever they exit (e.g., to ensure that they are not still holding any locks that have not been properly released and could cause significant problems in the server).
  
  
• Server threads are treated differently from non-server threads if they are still running when the server is in the course of shutting down. In the event that the shutdown process is taking too long, server threads more readily interrupted that non-server threads to speed the shutdown process.
  
  

If your extension may create one or more threads, then it also needs to ensure that those threads are properly shut down when the extension is disabled. In most cases, the finalize{ExtensionType} method should be careful to clean up any threads that were created by that extension. However, in some cases it may be desirable to have a thread or set of threads shared across multiple instances of an extension. In such cases, you will likely not want to destroy those threads whenever any one of those instances are disabled if there may still be other instances of the extension that are active. Rather, in this case you will either want to use some kind of reference counter to only shut down the threads when taking the last enabled instance of your extension out of service, or you may simply wish to use something like a ServerShutdownListener to ensure that the threads are notified when the server begins its shutdown process.