我要招人

去企业版

首页 > 试题广场 >

请实现一个单例模式的类，要求线程安全

[问答题]

请实现一个单例模式的类，要求线程安全

查看答案及解析

万QQ

class Singleton
{
private static Singleton instance;
//程序运行时创建一个静态只读的进程辅助对象
private static readonly object syncRoot = new object();
//构造方法让其private，堵死外界利用new创建此类实例的可能
private Singleton(){ }

//此方法是获得本类实例的唯一全局访问点
public static Singleton GetInstance()
{
if (instance == null)//先判断实例是否存在，不存在再加锁处理
{
lock (syncRoot)//在同一时刻，加了锁的那部分程序只有一个线程可以进入
{
if (instance == null)
{
instance = new Singleton();
}
}
}

return instance;
}
}

发表于 2015-06-16 10:24:14 回复(0)

simmon_hu

单例模式是设计模式中比较简单的一种。适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统，
它们都是原型的例子。典型的情况是，那些对象的类型被遍及一个软件系统的不同对象访问，因此需要一个全局的访问
指针，这便是众所周知的单例模式的应用。当然这只有在你确信你不再需要任何多于一个的实例的情况下。 
单例模式的用意在于前一段中所关心的。通过单例模式你可以：   一、确保一个类只有一个实例被建立 
二、提供了一个对对象的全局访问指针 
三、在不影响单例类的客户端的情况下允许将来有多个实例 经典的单例模式有三种，懒汉式、饿汉式和 登记式。

懒汉式的特点是延迟加载，比如配置文件，采用懒汉式的方法，顾名思义，懒汉么，很懒的，配置文件的实例直到用到的时候才会加载。。。。。。

饿汉式的特点是一开始就加载了，如果说懒汉式是“时间换空间”，那么饿汉式就是“空间换时间”，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。

classSingleton//懒汉模式

{

private:

Singleton(){}

public:

staticSingleton* p;

staticSingleton* getInstance();

};

Singleton* Singleton::p=NULL;

Singleton* Singleton::getInstance()

{

if(NULL==p)

{

if(mtx.try_lock())

{

p=newSingleton;

mtx.unlock();

}

returnp;

}

classSingleton//饿汉模式

{

private:

Singleton(){}

public:

staticSingleton* p;

staticSingleton* getInstance()

{

returnp;

}

};

Singleton* Singleton::p=newSingleton;

发表于 2015-06-11 20:43:52 回复(0)

noble4cc

class Singleton//懒汉模式
{
private:
    Singleton(){}
public:
    static Singleton* p;
    static Singleton* getInstance();
};
Singleton* Singleton::p=NULL;
Singleton* Singleton::getInstance()
{
    if(NULL==p)
    {
        if(mtx.try_lock())
        {
            p=new Singleton;
            mtx.unlock();
        }
    }
    return p;
}
class Singleton//饿汉模式
{
private:
    Singleton(){}
public:
    static Singleton* p;
    static Singleton* getInstance()
    {
        return p;
    }
};
Singleton* Singleton::p=new Singleton;

编辑于 2015-05-24 16:19:39 回复(1)

牛客184051号

懒汉模式 c++11之后线程安全因为只用一个线程会去初始化它 c++11 之前不安全饿汉模式线程安全因为在程序启动前就已经初始化了

发表于 2016-09-12 16:33:27 回复(0)

zhengying

public class Singleton {   
 private final static Singleton INSTANCE = new Singleton(); 

	   private Singleton() { }



	   public static Singleton getInstance() {
      return INSTANCE;
   }
}

编辑于 2015-09-28 11:03:11 回复(1)

KissGoodbye

package Jcode;


/**
 * 请实现一个单例模式的类，要求线程安全
 * @author Administrator
 *
 */
public class Item02 {

	/**
	 * 内部类
	 * @author Administrator
	 *
	 */
	private static class Singleton{
		private static Singleton sing = new Singleton();
	}
	
	/**
	 * 方式1.使用内部类的方式
	 * @return
	 */
	public static Singleton getInstance(){
		return Singleton.sing;
	}
	
	private static Single single;
	
	
	/**
	 * 方式2.使用double check instance
	 * @return
	 */
	public static Single getInstanceSingle(){
		if(single == null){
			synchronized(Item02.class){
				if(single == null){
					return new Single();
				}
			}
		}
		return single;
	}
	
}

class Single{
	
}

编辑于 2017-03-14 11:30:01 回复(0)

完美有多美

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		return m_Instance;
	}
	int GetTest()
	{
		return m_Test;
	}
private:
	Singleton() { m_Test = 10; }
	static Singleton *m_Instance;
	int m_Test;
	// This is important
	class GC
	{
	public:
		~GC()
		{
			// We can destory all the resouce here, eg:db connector, file handle and so on
			if (m_Instance != NULL)
			{
				cout << "Here is the test" << endl;
				delete m_Instance;
				m_Instance = NULL;
			}
		}
	};
	static GC gc;
};
Singleton *Singleton::m_Instance = new Singleton();
Singleton::GC Singleton::gc;
int main22(int argc, char *argv[])
{
	Singleton *singletonObj = Singleton::GetInstance();
	if (singletonObj)
	{
		cout << singletonObj->GetTest() << endl;
	}
	system("pause");
	return 0;
}

编辑于 2016-11-04 11:36:24 回复(0)

watChen

class Singleton{
private:
    Singleton(){};
    Singleton(const Singleton&s);
    Singleton& operator=(const Singleton &s);
public:
    static Singleton& getInstance(){
        static Singleton inst;
         return inst;
    }
};

发表于 2015-07-21 11:04:37 回复(0)

牛客152471643号

不用这么麻烦 Class sigle { Public: Static Sigle* instance() { Static Sigle sg; return &sg； } } Static声明的局部静态类，在编译完成的时候就已经是线程安全的了

发表于 2020-04-14 23:03:07 回复(0)

stt2019

https://blog.csdn.net/u012940886/article/details/80386669

发表于 2018-05-21 15:07:02 回复(0)

惊叹号...

多种，双端检测

发表于 2018-02-28 19:13:44 回复(0)

牛客6574009号

考虑到乱序执行，二重锁并不是线程安全的。返回局部变量的引用就行，c++标准保证它一定是线程安全的。

发表于 2017-09-23 19:01:24 回复(0)

冰封无痕

class  Single
{
	private Single(){}
	private static Single s = null;
	private static Single getInstance(){
		if(s == null){
			synchronized(Single.class){
				if(s == null){
					s = new Single();
				}
			}
		}
		return s;
	}
}

发表于 2017-01-15 23:25:48 回复(0)

我是谁谁谁呢

这是一个内部静态的懒汉模式

发表于 2015-10-08 19:36:26 回复(0)

缘故

class Singleton
{
private:

static Singleton instance;
Singleton();
Singleton(const Singleton &s);
Singleton& operator=(const Singleton &s);
public:
static Singleton* GetInstance()
{
return &instance;
}
};

发表于 2015-08-31 10:18:07 回复(0)

米醋

class Singleton()

{

private:

Singleton();

Singleton(const Singleton &s);

Singleton& operator = (const Singleton &s);

public:

static Singleton* getInstance()

{

static Singleton instance;

return &instance;

}

};

发表于 2015-07-26 20:34:25 回复(0)

小小娃爱吃甜食

http://www.cnblogs.com/ccdev/archive/2012/12/19/2825355.html

发表于 2015-07-09 11:45:30 回复(0)

陈木木

在C++之后，下面的实现是个线程安全的单例模式实现：

class Singleton
{
private:
 Singleton();
 Singleton(const Singleton &s);
 Singleton& operator=(const Singleton &s);
public:
 static Singleton* GetInstance()
 {
  static Singleton instance;
  return &instance;
 }
};

编辑于 2015-05-18 13:08:42 回复(1)

提交观点

问题信息

C++

上传者：陈木木

难度：

18条回答 315收藏 9417浏览

请实现一个单例模式的类，要求线程安全

问题信息

热门推荐

相关试题