Design Patterns in ActionScript-Singleton


In our real world, many things are one and only. For example, there is only one god in our world, and only one president in the USA, eh, I mean the current president. One and only is very important to our world, and so does to our program.



In some case, we may only need one instance of some classes. If you have any experience on developing the GUI application, you can feel it. For example, there’s only one display object in J2ME application, and only one form in windows application. During those situations, we need to control the number of the class, and it was forbidden that using the new operator to generate a new instance. Further more, we need to supply an interface for accessing the one and only instance.

That’s all about the singleton pattern. And the intent defined by GOF is as follows.

Ensure a class only has one instance, and provide a global point of access to it.


Now, we come to the operation layer.

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.

  1. public function President()
  2. {
  3. if(president != null)
  4. throw new Error(“You shouldn’t use the new operator!”);
  5. }

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 first problem. 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.

  1. static var president:President = new President();
  2. public static function getInstance():President
  3. {
  4. return president;
  5. }

The code below shows lazy initialization. As you see, after the getInstance() method was called, the instance will get initialized.

  1. static var president:President = null;
  2. public static function getInstance():President
  3. {
  4. if(president == null)
  5. president = new President();
  6. return president;
  7. }

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.

You can download the full source code from here.