单例模式--相关分析

在程序设计中，有些对象在整个程序运行过程中只需要有一个，而为了保证程序引用的对象是唯一的，

可以采用单例模式的方式来构造这些对象，以下就对单例进行简单的分析，（程序中涉及的技巧不再讨论，

这里简单说下思想）。

        （1）先写一个简单的单例模式（PHP）

class Singleton
{
	private static $sg;

	private function __construct()
	{}

	public static function getInstance()
	{
		if (NULL == self::$sg)
		{
			self::$sg = new Singleton();
		}

		return self::$sg;
	}

	public function tryPrint($value)
	{
		echo $value . "\n";
	}
}

由于PHP是单线程，所以对于PHP来说，单例到这一步可以暂停一步了，不过对于多线程的语言来说，还必须解决相关的问题

（2）处理多线程的单例模式（JAVA）

public class Singleton {
	
	private Singleton()
	{}
	
	private static Singleton sg;
	
	public static Singleton getInstance()
	{
		if (sg == null)
		{
			synchronized (Singleton.class)
			{
				if (sg == null)
				{
					sg = new Singleton();
				}				
			}
		}
		
		return sg;
	}

	public void test()
	{
		System.out.println("hahah");
	}
}

程序到这里，就可以完成在多线程情况下可能重复创建对象的问题，对于JAVA这种能够自动回收的语言来说，到这里也可以暂停一步了；可是C++这种需要程序自己去析构掉对象语言来说，到这里还会造成程序泄露，因为分配了对象，但是没有回收，针对这个问题，继续处理

（3）析构掉分配的对象（C++）

singleton.h

class Singleton
{
private:
	static Singleton *s;
	Singleton();
	~Singleton();

private:
	static Lock l;

public:
	static Singleton* getInstance();

	void print(int num);

private:
	class GC
	{
	public:
		~GC()
		{
			if (s != NULL)
			{
				delete s;
			}

			std::cout << "~GC" << std::endl;
		}

	};

private:
	static GC gc;
};

singleton.cpp

Singleton::GC Singleton::gc;

Lock Singleton::l;

Singleton* Singleton::s = NULL;

Singleton::Singleton()
{
	std::cout << "Singleton" << std::endl;
}

Singleton::~Singleton()
{
	std::cout << "~Singleton" << std::endl;
}

Singleton* Singleton::getInstance()
{
	if (NULL == s)
	{
		l.lock();
		if (NULL == s)
		{
			s = new Singleton();
		}
		l.unlock();
	}

	return s;
}

void Singleton::print(int num)
{
	std::cout << "num: " << num << std::endl;
}

这里对程序中创建的指针对象进行析构主要运用了“程序在退出时，系统会自动析构全局变量和类中的静态对象”，即析构静态对象的时候，来析构程序中可能已经创建的对象，到这里可以歇息了。不过，这种方式实现起来看起来比较丑陋，为了实现一个析构，添加了一个内部类和一个静态对象；而C++中有一块功能就是为了解决析构问题，那就是智能指针，而这一块主要是在应用程序书写过程中进行控制，这里就不在累赘。