单例 Singleton

actionscript ：

In general, we will meet two problems here, one is when to

initialize the instance and the other is how to ensure thread-safe in

the multithread environment. Because Action Script 3 doesn’t support

multithread, so we don’t need to care the thread-safe.

    Before we solve the first problem, we need to provide a global

access point for getting the instance. Of course, we don’t except the

users use the new operator to get a new instance. Maybe we could

change the constructor modifier from public to private. Eh, if you

really do so, you’ll get a complier error, because in Action Script 3, the

modifier of a constructor can only be public. So, we need to change our method.

If we can’t change the modifier, the constructor can be called

outside. One solution is we can throw an error in the constructor, just like below.

public function President()
{
    if(president != null)
    throw new Error("You shouldn't use the new operator!");
}

If there is already have an instance, we need to throw an error. If

not, let it go, and then we can get an instance.This is not a good way, but it works :).

    Now, let’s come to the firstproblem. In general, there will be two kinds solution.

One is called  early initialization , the other is lazy initialization . The first one

initializes the instance when the program first runs, and the other

initializes the instance when the getInstance () method called.

The code below shows early initialization. The instance will get

initialized when the class gets initialized.

static var president:President = new President();
public static function getInstance():President
{
    return president;
}

The code below shows lazy initialization. As you see, after the

getInstance() method was called, the instance will get initialized.

static var president:President = null;
public static function getInstance():President
{
    if(president == null)
    president = new President();
    return president;
}

 

Which way should be taken depends on your demand. Actually,

you’ll need to consider these two situations only when you using this

pattern to get a big object in the memory limit environment.

 

public class BallModelLocator
{
    private static var modelLocator :BallModelLocator;
    public function BallModelLocator()
    {
        if(modelLocator != null)
        throw new Error("You shouldn't use the new operator!");
    }
    // (lazy initialization)
    public static function getInstance() : BallModelLocator{
        if ( modelLocator == null )
            modelLocator = new BallModelLocator();
        return modelLocator;
    }
}

java ：

public class UserService {
    private UserService userService = null;

    private UserService() {}

    public static UserService getInstance() {
        if(userService == null) {
            synchronized(UserService.class) {
                if(userService == null) {userService = new UserService();}
            }
        }
    return userService;
    }
}