Mailing-List: contact dev-help@hbase.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@hbase.apache.org
Received-SPF: pass (athena.apache.org: local policy)
Message-ID: <4BFCA09C.1010801@aconex.com>
Date: Wed, 26 May 2010 14:16:28 +1000
From: Paul Cowan <cowan@aconex.com>
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.0; en-GB;
 rv:1.9.1.9) Gecko/20100317 Thunderbird/3.0.4
MIME-Version: 1.0
To: dev@hbase.apache.org
Subject: Re: Review Request: HBASE-2578
References: <20100526011535.21168.39066@ip-10-250-10-165.ec2.internal>
	 <20100526031513.21168.77683@ip-10-250-10-165.ec2.internal>
	 <4BFC99F5.3060006@aconex.com>
 <AANLkTimrynTI7NOk2YxapyjGhiYWp0_GZid81Mz9HRWh@mail.gmail.com>
In-Reply-To: <AANLkTimrynTI7NOk2YxapyjGhiYWp0_GZid81Mz9HRWh@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit

On 26/05/2010 1:54 PM, Ryan Rawson wrote:
> Thanks for that salient comment. Perhaps someone can give us the right
> pattern for no lock Singleton initialization.

There are really only two things which complicate thread-safe singletons:

1) Having a setter, so you can replace the singleton
2) Lazy initialization. The only excuse for this is having a 
horribly-expensive-to-create singleton, which may not even be used, and 
you don't under any circumstances wish to create it unless it's needed. 
This is hard to get right, and 99% of the time you should just 
instantiate it at class initializion time and forget it.

In this case, 1) applies, but 2) doesn't; luckily 1) is a lot easier to 
get right than 2).

Simplest 'correct' patterns are:


Basic Singleton (neither #1 nor #2 apply)
-------------------------------------------

public class Thing {
    private static final Thing INSTANCE = new AwesomeThing();

    public Thing get() {
       return INSTANCE;
    }
}

this is easy, simple, performant (no synchronization or locking at all) 
and 100% thread-safe (as long as INSTANCE is final).


Replacable Singleton (#1 applies)
-------------------------------------------
public class Thing {
    private static volatile Thing instance = new AwesomeThing(); // 
Note: volatile

    public Thing get() {
       return instance;
    }

    public void set(Thing newThing) {
       this.instance = newThing;
    }
}

Nearly as easy, all that's required here is a volatile instance which 
gives you the correct happens-before relationship.


Lazy-Initialized Singleton (#2 applies)
-------------------------------------------
Avoid if possible, but if not, one of:

Synchronized Getter:
    public synchronized Thing get() {
       if (instance == null) {
           instance = new AwesomeThing();
       }
       return instance;
    }

Double-checked locking (ONLY works in Java 5+)
    public Thing get() {
       if (instance == null) {
           synchronized (ThingHolder.class) {
              if (instance == null) { // Yes, you need this
                  instance = new AwesomeThing();
              }
          }
       }
       return instance;

Use java classloading locking guarantees + holder class (see: Effective 
Java)
    class ThingHolder {
        private static final Thing INSTANCE = new AwesomeThing();
    }

    class Thing {
        public Thing getThing() {
            return ThingHolder.instance;
        }
    }


Lazy-Initialized Settable Singleton (#1 + #2 apply)
-------------------------------------------
You almost certainly don't need this. You think you do, but you don't. 
Find a better way. :)


Hope that helps.

Cheers,

Paul