在程序设计中,有些对象在整个程序运行过程中只需要有一个,而为了保证程序引用的对象是唯一的,
可以采用单例模式的方式来构造这些对象,以下就对单例进行简单的分析,(程序中涉及的技巧不再讨论,
这里简单说下思想)。
(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++中有一块功能就是为了解决析构问题,那就是智能指针,而这一块主要是在应用程序书写过程中进行控制,这里就不在累赘。