1

Is it a good practice to make use of singleton object to process client requests?

As object instance is singleton, and if its in middle of processing a client request , and meanwhile another request arrives then same instance is invoked with new client data. Won't it make things messy?

Mandroid
  • 6,200
  • 12
  • 64
  • 134
  • 4
    Yes. Singletons with mutable state are evil – Boris the Spider Mar 15 '20 at 06:42
  • Though in my case, data is not set explicitly into the object. Instead it is passed as argument to processing function. – Mandroid Mar 15 '20 at 06:45
  • 1
    If the function is pure, what’s the issue? Are you somehow expecting two invocations of the same function to interfere?? – Boris the Spider Mar 15 '20 at 06:46
  • It could be messy, especially if your state is not prepared to be edited concurrently (for example you keep few fields that are updated separately in body of your function). In such cases you should care about `synchronized`, `volatile` or use Concurrent collections. Last option is preferred but still you need to understand how to use them properly. – Scalway Mar 15 '20 at 09:14

2 Answers2

3

When using singleton objects we must ensure everything inside it as well as everything it calls must be thread-safe. For example, javax.crypto.Cipher does not seem to be thread-safe, so it should probably not be called from a singleton. Consider how guice uses @Singleton to specify threadsafety intention:

@Singleton
public class InMemoryTransactionLog implements TransactionLog {
  /* everything here should be threadsafe! */
}

Also consider the example of Play Framework which starting version 2.4 began moving away from singleton controllers and started encouraging class controllers.

Mario Galic
  • 47,285
  • 6
  • 56
  • 98
2

It depends on whether the object holds any mutable data or not.

If the object is just a holder for pure functions and immutable state, it does not matter how many threads are using it at the same time because they can't affect each other via shared state.

If the object has mutable state then things can definitely go wrong if you access it from multiple threads without some kind of locking, either inside the object or externally.

So it is good practice as long as there is no mutable state. It is a good way of collecting related methods under the same namespace, or for creating a global function (by defining an apply method).

Tim
  • 26,753
  • 2
  • 16
  • 29