AS3.0中单例模式的实现

实现单例模式（Singleton Pattern）的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时将该类的构造函数定义为私有方法（AS3.0不支持），这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

单例模式在多线程的应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

 

下面是我在网上收集的AS3.0中单例模式的几种实现：

1、结合包外类的实现（主要用这条，后面几条只作思路，不推荐）：

 1 package com.cnblogs.matrix42.singletonexample
 2 {
 3     public class Singleton
 4     {
 5         static private var _instance:Singleton;
 6         public function Singleton(singletonEnforcer:SingletonEnforcer)
 7         {　　
 8             if (!singletonEnforcer)
 9             {
10                 throw new Error("Singleton is a singleton class");
11             }
12         }
13         public static function get instance():Singleton
14         {
15             Singleton._instance || (Singleton._instance = new Singleton(new SingletonEnforcer()));
16             return Singleton._instance;
17         }
18     }
19 }
20 
21 class SingletonEnforcer {}

 

2、

InstanceError类

 1 package com.cnblogs.matrix42.errors
 2 {
 3     public class InstanceError extends Error
 4     {
 5         public static const CONSTRUCTOR_ERROR:String = "ERROR";
 6         public function InstanceError(message:*="", id:*=0)
 7         {
 8             super(message, id);
 9         }
10     }
11 }

InstanceEnforcer类

 1 package com.cnblogs.matrix42.utils
 2 {
 3     import com.cnblogs.matrix42.errors.InstanceError;
 4     
 5     public class InstanceEnforcer
 6     {
 7         private static var num:uint;
 8         public static function enforceConstructor():void
 9         {
10             num++;
11             if (num >= 2)
12             {
13                 throw (new InstanceError(InstanceError.CONSTRUCTOR_ERROR));
14             }
15         } 
16     }
17 }

PressMouse类

 1 package com.cnblogs.matrix42.mouse
 2 {
 3     import com.cnblogs.matrix42.utils.InstanceEnforcer;
 4     import flash.events.EventDispatcher;
 5     
 6     final public class PressMouse extends EventDispatcher
 7     {
 8         public function PressMouse()
 9         {
10             InstanceEnforcer.enforceConstructor();
11         }
12         public static function instance():PressMouse
13         {
14             return new PressMouse();
15         }
16     }
17 }

 

3、

 1 package
 2 {
 3     public class Singleton
 4     {
 5         private static var _singletonModeMark:Boolean;
 6         private static var _instence:ScoreController;
 7         public static function getSingleton():Singleton
 8         {
 9             if (!_instence)
10             {
11                 _singletonModeMark = true;
12                 _instence = new ScoreController;
13                 _singletonModeMark = false;
14             }
15         }
16         public function Singleton():void
17         {
18             if (!_singletonModeMark)
19             {
20                 throw new Error("Error");
21             }
22         }
23     }
24 }

 

4、Cairngorm的Singleton实现

 1 package
 2 {
 3     public class BrickModel
 4     {
 5         private static var model:BrickModel;
 6         public static function getInstance():BrickModel
 7         {
 8             if(model == null)
 9             {
10                 model = new BrickModel();
11                 return model;
12             }
13         }
14         public function BrickModel()
15         {
16             if (BrickModel.model != null)
17             {
18                 throw new Error("Only one ModelLocator instance should be instantiated");
19             }
20         }
21     }
22 }

 

5、直接用静态定义类中的全部元素。

 

 

转载于:https://www.cnblogs.com/MATRIX42/archive/2012/08/03/2622365.html