我一直在阅读有关线程安全的单例模式:
http://en.wikipedia.org/wiki/Singleton_pattern#C.2B.2B_.28using_pthreads.29
它在底部说,唯一安全的方法是使用pthread_once - 这在Windows上不可用.
这是保证线程安全初始化的唯一方法吗?
我在SO上读过这个帖子:
并且似乎暗示了原子操作系统级别的交换和比较功能,我在Windows上假设:
http://msdn.microsoft.com/en-us/library/ms683568.aspx
这可以做我想要的吗?
编辑:我想懒惰的初始化,因为只有一个类的实例.
另一个网站上有人提到在命名空间中使用全局(并且他将单例描述为反模式) - 它如何成为"反模式"?
一般承认的答案:
我已经接受了Josh的回答,因为我正在使用Visual Studio 2008 - 注意:对于未来的读者,如果您不使用此编译器(或2005) - 请勿使用接受的答案!
编辑: 除了return语句之外代码工作正常 - 我收到错误:错误C2440:'return':无法从'volatile Singleton*'转换为'Singleton*'.我应该将返回值修改为易失性Singleton*吗?
编辑:显然const_cast <>将删除volatile限定符.再次感谢Josh.
这就是我对"CLR via C#","Effective C#"和其他资源的IDisposable和终结器的理解:
虽然我理解并推理上述所有内容,但有一种情况我认为打破这些规则是有意义的:负责非托管资源的单例类(例如提供对特定文件的单点访问) ).
我认为在单例上使用Dispose()方法总是错误的,因为单例实例应该在应用程序的生命周期中存在,如果任何客户端代码调用Dispose(),那么你就被填充了.但是,您需要一个终结器,以便在卸载应用程序时,终结器可以清理非托管资源.
因此,在我看来,使用没有实现IDisposable的终结器的单例类似乎是一件合理的事情,但这种类型的设计与我所理解的最佳实践相反.
这是一种合理的方法吗?如果没有,为什么不呢?有哪些优越的选择?
就在前几天,我看到了使用所谓的单例模式的代码.意思是某些东西
class MySingleton{
public:
void foo() { ... }
static MySingleton&get_instance(){
static MySingleton singleton;
return singleton
}
private:
MySingleton(){ ... }
~MySingleton(){ ... }
int bar;
};
Run Code Online (Sandbox Code Playgroud)
我确实想知道为什么会这样做:
但是,我不明白为什么这种做事方式优于一些免费功能.我实施它的方式是放
namespace some_name{
void foo();
}
Run Code Online (Sandbox Code Playgroud)
在标题和
namespace some_name{
void foo(){
...
}
}
Run Code Online (Sandbox Code Playgroud)
在实现文件中.如果我需要初始化和/或清理,我要么添加一些必须显式调用或添加的函数
namespace{
class Dummy{
Dummy(){ ... }
~Dummy(){ ... }
}dummy;
}
Run Code Online (Sandbox Code Playgroud)
进入实施文件.
我知道这是从语义的角度来看单例,但是我看到第一个变体在C++代码中使用得比第二个更常见.为什么?我认为第二个版本略胜一筹,所以我问自己是否遗漏了一些明显的东西.
你能解释一下为什么每个人都使用第一个变种吗?我没有看到在C语言中做旧事情的单一优势.
懒惰的线程安全单例实例对每个编码器来说都不容易理解,所以我想在我们的企业框架中创建一个可以完成这项工作的类.
你怎么看待这件事?你觉得它有什么坏处吗?在Apache Commons中有类似的东西吗?我怎样才能让它变得更好?
Supplier.java
public interface Supplier<T> {
public T get();
}
Run Code Online (Sandbox Code Playgroud)
LazyThreadSafeInstantiator.java
public class LazyThreadSafeInstantiator<T> implements Supplier<T> {
private final Supplier<T> instanceSupplier;
private volatile T obj;
public LazyThreadSafeInstantiator(Supplier<T> instanceSupplier) {
this.instanceSupplier = instanceSupplier;
}
@Override
// http://en.wikipedia.org/wiki/Double-checked_locking
public T get() {
T result = obj; // Wikipedia: Note the usage of the local variable result which seems unnecessary. For some versions of the Java VM, it will make the code 25% faster and for others, it won't hurt.
if …Run Code Online (Sandbox Code Playgroud) 在guice中,@ Singleton范围不涉及Singleton模式.
根据"Dhanji"的"依赖注入"一书:
很简单,单例的上下文就是注入器本身.单身的寿命与注射器的寿命有关(如图5.8所示).因此,每个注射器只创建一个单例实例.重要的是要强调最后一点,因为多个喷射器可能存在于同一应用中.在这种情况下,每个注入器将保存单例范围对象的不同实例.

是否可以通过多个模块和多个喷射器共享同一个Singleton实例?
如果我必须在使用该对象之前初始化它,那么初始化基于java enum的单例的正确方法是什么.
我已经开始编写代码,但我不确定我是否做得对.你能帮我实现这个单身对我来说正确吗?
public enum BitCheck {
INSTANCE;
private static HashMap<String, String> props = null;
public synchronized void initialize(HashMap<String, String> properties) {
if(props == null) {
props = properties;
}
}
public boolean isAenabled(){
return "Y".equalsIgnoreCase(props.get("A_ENABLED"));
}
public boolean isBenabled(){
return "Y".equalsIgnoreCase(props.get("B_ENABLED"));
}
}
Run Code Online (Sandbox Code Playgroud) 我的具体问题是,在C++中实现单例类时,以下两个代码之间在性能,方面问题或其他方面存在实质性差异:
class singleton
{
// ...
static singleton& getInstance()
{
// allocating on heap
static singleton* pInstance = new singleton();
return *pInstance;
}
// ...
};
Run Code Online (Sandbox Code Playgroud)
还有这个:
class singleton
{
// ...
static singleton& getInstance()
{
// using static variable
static singleton instance;
return instance;
}
// ...
};
Run Code Online (Sandbox Code Playgroud)
(请注意,基于堆的实现中的解除引用不应该影响性能,因为AFAIK没有为解除引用生成额外的机器代码.似乎只需要语法来区分指针.)
更新:
我有一些有趣的答案和评论,我试着在这里总结一下.(建议有兴趣的人阅读详细的答案.):
static singleton& getInstance() {
static std::auto_ptr<singleton> instance (new singleton());
return *instance.get();
}
Run Code Online (Sandbox Code Playgroud)
使用动态分配的单例比静态单例变量"更懒惰",如后一种情况,单例对象所需的内存(始终?)在进程启动时保留(作为加载程序所需的整个内存的一部分)并且只调用单例构造函数被推迟到getInstance()调用时.这可能sizeof(singleton)很重要.
两者都是C++ 11中的线程安全的.但是对于早期版本的C++,它是特定于实现的. …
我有以下Singleton策略类实现:
template <typename T>
class Singleton
{
Singleton(){}; // so we cannot accidentally delete it via pointers
Singleton(const Singleton&) = delete; // no copies
Singleton& operator=(const Singleton&) = delete; // no self-assignments
Singleton(Singleton&&) = delete; // WHY?
Singleton& operator=(Singleton&&) = delete; // WHY?
public:
static T& getInstance() // singleton
{
static T instance; // Guaranteed to be destroyed.
// Instantiated on first use.
// Thread safe in C++11
return instance;
}
};
Run Code Online (Sandbox Code Playgroud)
然后我通过奇怪的重复模板模式(CRTP)使用
class Foo: public Singleton<Foo> // now Foo …Run Code Online (Sandbox Code Playgroud) 我们在get上使用双重锁定实现了一个延迟加载的单例,以确保实例仅初始化一次(而不是由于线程竞争条件而导致的两次).
我想知道如果简单地使用Lazy<T>是一个很好的解决方案吗?
IE
private static Lazy<MyClass> _instance = new Lazy<MyClass>(() => return new MyClass());
public static MyClass Instance
{
get
{
return _instance.Value;
}
}
Run Code Online (Sandbox Code Playgroud)