设计模式之单例模式（Singleton）

设计模式之单例模式（Singleton）

    单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

    Objective-C实现 

     双重检查锁定(Double-Check Locking)

    .h文件

#import <Foundation/Foundation.h>

@interface Singleton : NSObject
+ (Singleton *) sharedInstance;
@end

    .m文件 

#import "Singleton.h"

@implementation Singleton

static Singleton *sharedObj = nil;
+ (Singleton *) sharedInstance{
	if(nil == sharedObj){//第一层判断
		@synchronized(self){//加锁以免多线程出现问题
			if(nil == sharedObj){//第二层判断
				sharedObj = [[self alloc] init];
			}
		}
    }
    return sharedObj;
}
+ (id) allocWithZone:(NSZone *)zone{
	if(nil == sharedObj){//第一层判断
		@synchronized(self){//加锁以免多线程出现问题
			if(nil == sharedObj){//第二层判断
				sharedObj = [super allocWithZone:zone];
				return sharedObj;
			}
		}
    }
    return sharedObj;
}
- (id) copyWithZone:(NSZone *)zone{
    return self;
}
- (NSUInteger) retainCount{
    return UINT_MAX;
}
- (oneway void) release{
  //不做任何事情  
}
- (id) autorelease{
    return self;
}
- (id) init{
    return [Singleton sharedObj];
}

    Java实现

    一般实现(懒汉式单例模式的一般实现)

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

    饿汉式单例模式

class Singleton{
	private static Singleton instance = new Singleton();
	private Singleton(){}
	public static Singleton getInstance(){
		return instance;
	}
}

    懒汉式单例模式

    

    懒汉式单例模式的一般实现如上。 

    加上线程锁定

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

    改进 - 延迟加载(Lazy Load)技术

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

    进一步改进 - 双重检查锁定(Double-Check Locking)

class Singleton{
	private volatile static Singleton instance = nill;
	private Singleton(){}
	public static Singleton getInstance(){
		if(null == instance){//第一层判断
			synchronized(Singleton.class){//加锁以免多线程出现问题
				if(null == instance){//第二层判断
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

    一种更好的单例模式实现方法(Initialization on Demand Holder - IoDH)

class Singleton{
	private Singleton(){}
	private static class HolderClass{ //内部类
		private final static Singleton instance = new Singleton();
	}
	public static Singleton getInstance(){
		return HolderClass.instance;
	}
}

    C++实现

#include <iostream>
using namespace std;

class Singelton
{
private:
	Singelton(){}
	static Singelton* m_pInstance;

public:
	static Singelton* GetInstance()
	{
		if(m_pInstance == NULL)
		{
			m_pInstance = new Singelton();
		}
		return m_pInstance;
	}

};
Singelton* Singelton::m_pInstance = NULL;//注意静态变量类外初始化

    另一种实现

class CSingleton:
{
    // 其它成员 
public: 
    static CSingleton * GetInstance() 
private: 
    CSingleton(){}; 
    static CSingleton * m_pInstance; 
    class CGarbo // 它的唯一工作就是在析构函数中删除CSingleton的实例 
    {
    public:
        ~CGarbo()
        { 
            if (CSingleton::m_pInstance)
                delete CSingleton::m_pInstance;
        }
    };
    static CGarbo Garbo; // 声明一个静态成员，在程序结束时，系统会调用它的析构函数，注意这里仅仅是声明，还需要在相应的cpp文件中对静态成员进行定义哦。
};
//静态成员定义（cpp文件）
CSingleton* CSingleton::m_pInstance = NULL;
CSingleton::CGarbo CSingleton::Garbo;

    C#简单实现

// Singleton pattern -- Structural example  
using System;
// "Singleton"
class Singleton
{
  // Fields
  private static Singleton instance;
  // Constructor
  protected Singleton() {}
  // Methods
  public static Singleton Instance()
  {
    // Uses "Lazy initialization"
    if( instance == null )
      instance = new Singleton();
    return instance;
  }
}

转载于:https://my.oschina.net/jajy24/blog/161589