volatile单例模式（单例模式双重锁为啥要volitie修饰：）

本文目录

• 单例模式双重锁为啥要volitie修饰：
• 单例模式没有抽象层
• 项目实战—那些年常用的单例模式
• 单例模式为什么还要用volatile
• 如何实现一个单例模式 c#双重锁检查
• 设计模式之单例模式
• 如何用Java实现单例模式

单例模式双重锁为啥要volitie修饰：

单例模式双重锁为啥要volitie修饰：

volatile关键字可以防止jvm指令重排优化，使用了volatile关键字可用来保证其线程间的可见性和有序性；

因为对象的创建并非一步完成，而是需要分为3个步骤执行的，比如：singleton = new Singleton();  

指令1：获取singleton对象的内存地址

指令2：初始化singleton对象

指令3：将内存地址指向引用变量singleton

因为Volatile禁止JVM对指令进行重排序，所以创建对象时会严格按照指令1-2-3的顺序执行，假若如果没有Volatile关键字，单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。比如

线程A正常创建一个实例，执行了1-3，此时线程B调用getInstance()后发现instance不为空，因此会直接返回instance，但此时instance并未被初始化，所以需要用volatile关键字修饰

单例模式没有抽象层

是的。

单例模式指的是一种常用的软件设计模式，类创建单一实例以满足多方调用，即一个类只有一个对象实例。优点在于单例模式只构建单一实例，供多个方法使用，避免多个方法构造同个类多个对象，减少内存的开销。缺点在于单例模式没有接口，也没有抽象层，扩展性性差，如需扩展，需在原有代码上进行修改。

单例模式实现方式

1、懒汉式—线程不安全：最基础的实现方式，线程上下文单例，不需要共享给所有线程，也不需要加synchronize之类的锁，以提高性能。

2、懒汉式—线程安全：加上synchronize之类保证线程安全的基础上的懒汉模式，相对性能很低，大部分时间并不需要同步。

3、饿汉方式。指全局的单例实例在类装载时构建。

4、双检锁式。在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建时没有线程间竞争而产生多个实例，仅第一次创建时同步，性能相对较高。

5、登记式。作为创建类的全局属性存在，创建类被装载时创建。

6、枚举。java中枚举类本身也是一种单例模式。

项目实战—那些年常用的单例模式

饿汉式单例：类初始化时将单例对象加载到JVM中。

懒汉式单例：并发写时，存在线程安全问题。进化版： 双重检查锁模式 。

volatile关键字详见— Volatile可见性原理

除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象，所以如果我们想要阻止单例破坏，可以在构造方法中进行判断，若已有实例, 则阻止生成新的实例，解决办法如下:

如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例，所以我们可以不实现序列化接口,如果非得实现序列化接口，可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。

枚举类来实现单例模式

单例模式为什么还要用volatile

减少系统资源开销，由于单例只保留一个对象。
提高创建速度，每次都获取已经存在的对象因此提高创建速度
全局共享对象，由于单例在系统中只存在一个对象实例，因此任何地方使用此对象都是一个对象
避免多实例创建使用时产生的逻辑错误。
使用案例：
线程池、缓存、日志对象、打印机、显卡的驱动程序
希望能帮到你！

如何实现一个单例模式 c#双重锁检查

你好！以下是标准的Singleton pattern with Double-check lock。

    public class SingletonClass
    {
        private static readonly object _lock = new object();
        private static volatile SingletonClass _instance;
        public static SingletonClass Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            _instance = new SingletonClass();
                        }
                    }
                }
                return _instance;
            }
        }
        private SingletonClass()
        {
            //your constructor
        }
    }

如果你的.NET在4.0以上，可以借助Lazy《T》泛型更优雅的实现单例模式：

    public class LazySingleton
    {
        private static readonly Lazy《LazySingleton》 _instance = new Lazy《LazySingleton》(() =》 new LazySingleton());
        private LazySingleton()
        {
            //your constructor
        }
        public static LazySingleton Instance { get { return _instance.Value; } }
    }

设计模式之单例模式

单例设计模式理解起来非常简单。一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫单例模式。

下面的示例中如果每个类都创建一个 Logger 实例，就可能造成日志内容被覆盖的情况。

如果有些数据在系统中只应保存一份，那就比较适合设计为单例类。比如，配置信息类，全局 ID 生成器等。

要实现一个单例，我们要考虑以下几点：

懒汉式相对于饿汉式的优势是 「支持延迟加载」 。但缺点也很明显，因为使用了 synchronized 关键字导致这个方法的 「并发度很低」 。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，就会导致性能瓶颈，这种实现方式就不可取了。

这是一种既支持延迟加载、又支持高并发的单例实现方式。

在 java1.5 以下 instance = new Singleton(); 有指令重排问题，需要给 instance 成员变量加上 volatile 关键字，java1.5 之后不会再这个问题。

这种方式利用了 Java 的静态内部类，有点类似饿汉式，但又能做到了延迟加载。

当外部类 Singleton 被加载的时候，并不会创建 SingletonHolder 实例对象。只有当调用 getInstance() 方法时，SingletonHolder 才会被加载，这个时候才会创建 instance。insance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。

这是一种最简单的实现方式，基于枚举类型的单例实现。这种实现方式是通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。

上面的单例类对象是进程唯一的，一个进程只能有一个单例对象。那如何实现一个线程唯一的单例呢？

假设 IdGenerator 是一个线程唯一的单例类。在线程 A 内，我们可以创建一个单例对象 a。因为线程内唯一，在线程 A 内就不能再创建新的 IdGenerator 对象了，而线程间可以不唯一，所以，在另外一个线程 B 内，我们还可以重新创建一个新的单例对象 b。

我们通过一个 ConcurrentHashMap 来存储对象，其中 key 是线程 ID，value 是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java 语言本身提供了 ThreadLocal 工具类，可以更加轻松地实现线程唯一单例。

如何用Java实现单例模式

单例模式：就是一个类仅创建一个对象；《pre t="code" l="java"》public class Singleton {
private static volatile Singleton singleton = null;
private Singleton(){}// 构造方法
public static Singleton getSingleton(){// 单例模式
if(singleton == null){
synchronized (Singleton.class){
if(singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
}