标签: singleton

如何在Windows中创建线程安全的单例模式?

我一直在阅读有关线程安全的单例模式:

http://en.wikipedia.org/wiki/Singleton_pattern#C.2B.2B_.28using_pthreads.29

它在底部说,唯一安全的方法是使用pthread_once - 这在Windows上不可用.

这是保证线程安全初始化的唯一方法吗?

我在SO上读过这个帖子:

C++中单例的线程安全延迟构造

并且似乎暗示了原子操作系统级别的交换和比较功能,我在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.

c++ windows singleton

16
推荐指数
2
解决办法
2万
查看次数

单身人士与终结者但不是IDisposable

这就是我对"CLR via C#","Effective C#"和其他资源的IDisposable和终结器的理解:

  • IDisposable用于确定性地清理托管和非托管资源.
  • 负责非托管资源的类(例如文件句柄)应该实现IDisposable并提供终结器以保证它们被清除,即使客户端代码没有在实例上调用Dispose().
  • 仅负责托管资源的类永远不应实现终结器.
  • 如果你有一个终结器,那么你必须实现IDisposable(这允许客户端代码做正确的事情并调用Dispose(),而终结器可以防止泄漏资源,如果他们忘记).

虽然我理解并推理上述所有内容,但有一种情况我认为打破这些规则是有意义的:负责非托管资源的单例类(例如提供对特定文件的单点访问) ).

我认为在单例上使用Dispose()方法总是错误的,因为单例实例应该在应用程序的生命周期中存在,如果任何客户端代码调用Dispose(),那么你就被填充了.但是,您需要一个终结器,以便在卸载应用程序时,终结器可以清理非托管资源.

因此,在我看来,使用没有实现IDisposable的终结器的单例类似乎是一件合理的事情,但这种类型的设计与我所理解的最佳实践相反.

这是一种合理的方法吗?如果没有,为什么不呢?有哪些优越的选择?

.net c# singleton idisposable

16
推荐指数
2
解决办法
3963
查看次数

Singleton - 为什么要使用类?

就在前几天,我看到了使用所谓的单例模式的代码.意思是某些东西

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语言中做旧事情的单一优势.

c++ singleton

16
推荐指数
2
解决办法
3738
查看次数

java中延迟线程安全单例实例化的模式

懒惰的线程安全单例实例对每个编码器来说都不容易理解,所以我想在我们的企业框架中创建一个可以完成这项工作的类.

你怎么看待这件事?你觉得它有什么坏处吗?在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)

java singleton instantiation thread-safety lazy-evaluation

16
推荐指数
2
解决办法
1万
查看次数

Guice - 如何通过多个喷射器/模块共享同一个Singleton实例

在guice中,@ Singleton范围不涉及Singleton模式.

根据"Dhanji"的"依赖注入"一书:

很简单,单例的上下文就是注入器本身.单身的寿命与注射器的寿命有关(如图5.8所示).因此,每个注射器只创建一个单例实例.重要的是要强调最后一点,因为多个喷射器可能存在于同一应用中.在这种情况下,每个注入器将保存单例范围对象的不同实例.

单身范围

是否可以通过多个模块和多个喷射器共享同一个Singleton实例?

java singleton dependency-injection guice

16
推荐指数
1
解决办法
1万
查看次数

如何初始化基于Java枚举的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)

java singleton enums

16
推荐指数
2
解决办法
2万
查看次数

C++单例类实例的堆/动态与静态内存分配

我的具体问题是,在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++,它是特定于实现的. …

c++ memory singleton static dynamic-memory-allocation

16
推荐指数
1
解决办法
9094
查看次数

Java单例是否应该使用静态变量?

Java中的单例是否应该使用静态变量或成员变量?两者都有任何优势吗?

java singleton

16
推荐指数
3
解决办法
2万
查看次数

为什么我要删除移动构造函数并在单例中移动赋值运算符?

我有以下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)

c++ singleton move-semantics c++11

16
推荐指数
1
解决办法
1万
查看次数

Lazy <T>是一个线程安全的懒加载单例的好解决方案吗?

我们在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)

c# singleton multithreading

16
推荐指数
1
解决办法
7870
查看次数