You are implementing the lazy initialization pattern – where the instance is created when first used. But there is a simple trick that allows you to code a threadsafe implementation that doesn’t require synchronization! It is known as the Initialization-on-demand holder idiom, and it looks like this: public class CassandraAstyanaxConnection { private CassandraAstyanaxConnection(){ } private … Read more
No, since you are obtaining lock on the SearchBox.class, only one thread will enter the synchronized block at a time. So the first thread enters then finds searchBox is null and creates it and then leaves the synchronized block, then the second thread enter the block then it finds that the searchBox is not null … Read more
User kaizer.se was onto something as far as the original question goes. I took it a step further in terms of simplicity, so that it now requires only a single decorator: class classproperty(property): def __get__(self, cls, owner): return classmethod(self.fget).__get__(None, owner)() Usage: class Stats: _current_instance = None @classproperty def singleton(cls): if cls._current_instance is None: cls._current_instance = … Read more
Tip: To create singleton class In Android Studio, right click in your project and open menu: New -> Java Class -> Choose Singleton from dropdown menu
Click here to see my blog post on this subject. Here is some sample code that illustrates three possible approaches. These will allow access to the database throughout the application. Approach #1: have `SQLiteOpenHelper` be a static data member This isn’t the complete implementation, but it should give you a good idea on how to … Read more
I know this is old, but Dr8k’s answer was almost there. When you are considering writing a piece of code, assume it’s going to change. That doesn’t mean that you’re assuming the kinds of changes it will have hoisted upon it at some point in the future, but rather that some form of change will … Read more
If you are using C++11, here is a right way to do this: Foo& getInst() { static Foo inst(…); return inst; } According to new standard there is no need to care about this problem any more. Object initialization will be made only by one thread, other threads will wait till it complete. Or you … Read more
I put a logger instance in my dependency injection container, which then injects the logger into the classes which need one.
A good resource for understanding why volatile is needed comes from the JCIP book. Wikipedia has a decent explanation of that material as well. The real problem is that Thread A may assign a memory space for instance before it is finished constructing instance. Thread B will see that assignment and try to use it. … Read more
Suppose you’re binding to something which will use the properties of any object it’s given – you can pass Elvis.INSTANCE very easily, but you can’t pass Elvis.class and expect it to find the property (unless it’s deliberately coded to find static properties of classes). Basically you only use the singleton pattern when you want an … Read more