A Statikus osztályokkal szemben kivédi az estleges körkörös osztályreferenciákkal járó hibákat azzal, hogy csak akkor jön létre a példány amikor használni szeretnénk, továbbá lehetőségünk van más osztályokból származtatni pl EventDispatcher így eseményeket is tud egyszerűen dobni amiket a statikus osztályoknál lényegesen több kóddal érhetnénk el.
A példányok lekérésére a statikus getInstance() nevű metódus használható.

Mivel AS3-ban nincs lehetőség privát konstruktor létrehozására amit Adobe az ECMAScript specifikációval való kompatibilitás megtartásával indokol trükkök segítségével kell elérnünk a kívánt hatást, erre több módszert fogok bemutatni.

Tipikus Viselkedés:

var classInstance:Singleton = new Singleton() //Hiba

var classInstance:Singleton = Singleton.getInstance() //Sikeres művelet

Első módszer hogy létrehozunk egy Boolean típusú változót ami felügyelni fogja hogy csak a getInstance() meghívásával hozhassunk létre példányt az osztályunkból. Ha az osztályt final-al definiáljuk kivédhetjük hogy származtatással kicselezzék a védelmünket.

singletons.Singleton1.as

package singletons
{
	import flash.utils.getQualifiedClassName;

	public final class Singleton1
	{
		private static var instance:Singleton1
		private static var allowInstantiation:Boolean

		public function Singleton1()
		{
			if(!allowInstantiation){
				throw new Error("You have to use getInstance() to instantiate "+getQualifiedClassName(this))
			}
		}

		public function getSomeText():String
		{
			return "Some Text"
		}

		public static function getInstance():Singleton1
		{
			if(!instance){
				allowInstantiation = true;
				instance = new Singleton1()
				allowInstantiation = false;
			}
			return instance
		}
	}
}

Előnyök:
Jól néz ki a dokumentációban mivel nincsenek felesleges paraméterei. Kívülről klasszikus Singleton.

Hátrányok:
Nem kapunk fordítási időben figyelmeztetést hogy egy Singleton-t próbálunk példányosítani.

A következő módszerben egy, AS3-ban bevezetett ún. “segéd osztályt” fogunk használni amit csak az osztályon belülről lehet példányosítani így ha azt konstruktor paraméternek használjuk csak az osztály fog tudni magáról példányt készíteni. Fontos odafigyelni hogy mint minden más komplexebb adattípusnak ennek is átadható lenne a null mint érték ezért ezt le kell védenünk.

singletons.Singleton2.as

package singletons
{
	import flash.utils.getQualifiedClassName;

	public class Singleton2
	{
		private static var instance:Singleton2

		public function Singleton2(k:Key)
		{
			if(!k) throw new Error("You have to use getInstance() to instantiate "+
					getQualifiedClassName(this));
		}

		public function getSomeText():String
		{
			return "Some Text"
		}

		public static function getInstance():Singleton2
		{
			if(!instance){
				instance = new Singleton2(new Key())
			}
			return instance
		}
	}
}
internal class Key{}

Előnyök:
Nem megfelelő használat esetén fordítási időben értesítést kapunk hogy hiányzik egy paraméter.

Hátrányok:
A kényszerítés módja nem biztos hogy mindenkinek szimpatikus.

Amennyiben nem szeretnénk az osztály kódjába Singleton specifikus megszorításokat írni mégis szeretnénk kihasználni a pattern előnyeit, készíthetünk egy külső manager osztályt ami a példányosítást elvégzi helyettünk és figyel hogy mindig csak 1 példány létezhessen.

managers.SingletonManager.as

package managers
{
	import flash.utils.Dictionary;

	public class SingletonManager
	{
		private static var instanceMap:Dictionary = new Dictionary();

		public function SingletonManager()
		{
			throw new Error("SingletonManager is a static class");
		}

		public static function getClassInstance(clazz:Class):*
		{
			if(instanceMap[clazz] == null){
				instanceMap[clazz] = new clazz();
			}

			return instanceMap[clazz];
		}
	}
}

Használata egyszerű, mondjuk hogy van egy NumberHolder nevű osztályunk aminek csak annyi a feladata hogy egy számot tárol és így néz ki:

NumberHolder.as

package
{
	public class NumberHolder
	{
		public var currentNumber:Number = 0
	}
}

Egyszerűen példányosíthatjuk a SingletonManager segítségével és később csak a már létrehozott példányt fogjuk visszakapni, ezt szemlélteti a következő példa:

var numholder1:NumberHolder = SingletonManager.getClassInstance(NumberHolder);
trace(numholder1.currentNumber); // 0

numholder1.currentNumber = 10;

var numholder2:NumberHolder = SingletonManager.getClassInstance(NumberHolder);
trace(numholder2.currentNumber); //10

Előnyök:
Akármilyen konstruktor paraméter nélküli osztály használható, nem kell a kódját kiegészíteni.

Hátrányok:
Lehetőség van megkerülni és új példányt létrehozni.

Persze ez nem az összes lehetséges megvalósítás volt de a legnépszerűbbeket szerintem sikerült felsorolnom. Látható hogy mennyire hasznos lehet bizonyos esetekben például egy StageManager osztály létrehozásával egyszerűen akárhonnan elérhető lesz a Stage a programunkon belül.