1. 饿汉式

实现代码:

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

验证一下:

    public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance(); System.out.println(s1 == s2);
// true
}

如果用反射, 是否仍然是单例:

结果是反射破坏了单例

    public static void main(String[] args) throws Exception {
// 自定义单例方法获取
Singleton s1 = Singleton.getInstance(); // 反射获取
Constructor constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton s2 = (Singleton) constructor.newInstance(); System.out.println(s1 == s2);
//false
}

2. 懒汉式

将上面的饿汉式改为懒汉式:

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

验证一下:

    public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance(); System.out.println(s1 == s2);
// true
}

不过这是一种线程不安全的单例实现.

我们在Singleton中加上sleep来模拟一下线程切换:

public class Singleton {
private Singleton() {
} private static Singleton singleton; public static Singleton getInstance() {
if (singleton == null) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
singleton = new Singleton();
}
return singleton;
}
}

验证一下线程不安全:

public class Main3 {
private static LinkedBlockingQueue<Singleton> singletons = new LinkedBlockingQueue<>();
public static void main(String[] args) throws Exception{
ExecutorService threadPool = Executors.newFixedThreadPool(10);
for(int i= 0;i<100;i++){
threadPool.execute(()->{
singletons.offer(Singleton.getInstance());
});
} Singleton basic = singletons.take();
while(basic==singletons.take()){
System.out.println("continue");
continue;
} System.out.println("走到这里说明单例失败");
}
}

3. 懒汉式+同步方法

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

验证一下:

    public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance(); System.out.println(s1 == s2);
// true
}

由于是同步, 所以同步方法内不会出现多线程执行的情况.

4. 懒汉式+双重校验锁

因为上面那种会每次进时都会进行同步锁, 很浪费性能, 所以在加锁之间先进行校验

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

验证一下性能:

能明显看出来性能差距...5千倍...

同步方法, 即直接在方法声明处加了Synchronize的情况:

    public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}

双重校验锁:

    public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}

5. 懒汉式+双重校验锁+防止指令重拍

看似简单的一段赋值语句:instance = new Singleton(); 其实JVM内部已经转换为多条指令:

memory = allocate(); //1:分配对象的内存空间

ctorInstance(memory); //2:初始化对象

instance = memory; //3:设置instance指向刚分配的内存地址

但是经过重排序后如下:

memory = allocate(); //1:分配对象的内存空间

instance = memory; //3:设置instance指向刚分配的内存地址,此时对象还没被初始化

ctorInstance(memory); //2:初始化对象

可以看到指令重排之后,instance指向分配好的内存放在了前面,而这段内存的初始化被排在了后面,在线程A初始化完成这段内存之前,线程B虽然进不去同步代码块,但是在同步代码块之前的判断就会发现instance不为空,此时线程B获得instance对象进行使用就可能发生错误。

加上volatile关键字:

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

验证一下性能:

能明显看出来加了volatile后对性能的影响, 由之前的5, 变为了302...

性能下降了, 但是相比于上面的双重校验锁, 更保证了线程安全.

    public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}

6. 静态内部类

这也是一种很好的实现方式, 不仅懒加载, 还保证了线程安全, 性能也很好, 实现起来也很简单

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

验证一下性能:

public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}

7. 枚举

个人对枚举类型的理解还有限, 有待学习....

public enum Singleton {
INSTANCE; private String name; Singleton() {
this.name = "king";
}
public static Singleton getInstance() {
return INSTANCE;
} public String getName() {
return this.name;
}
}

验证一下性能:

    public static void main(String[] args){
long start = System.currentTimeMillis();
for(int i= 0;i<999999999;i++){
Singleton s = Singleton.getInstance();
}
System.out.println(System.currentTimeMillis()-start);
}

单例模式的七种实现-Singleton(Java实现)的更多相关文章

  1. Java设计模式之单例模式(七种写法)

    Java设计模式之单例模式(七种写法) 第一种,懒汉式,lazy初始化,线程不安全,多线程中无法工作: public class Singleton { private static Singleto ...

  2. Java 单例模式的七种写法

    Java 单例模式的七种写法 第一种(懒汉,线程不安全) public class Singleton { private static Singleton instance; private Sin ...

  3. Android设计模式之单例模式的七种写法

    一 单例模式介绍及它的使用场景 单例模式是应用最广的模式,也是我最先知道的一种设计模式.在深入了解单例模式之前.每当遇到如:getInstance()这样的创建实例的代码时,我都会把它当做一种单例模式 ...

  4. Java:单例模式的七种写法

    第一种(懒汉,线程不安全): 1 public class Singleton { 2 private static Singleton instance; 3 private Singleton ( ...

  5. Java:单例模式的七种写法(转载)

    第一种(懒汉,线程不安全): package Singleton; /** * @echo 2013-10-10 懒汉 线程不安全 */ public class Singleton1 { priva ...

  6. Java:单例模式的七种写法[转]

    第一种(懒汉,线程不安全):  1 public class Singleton {   2     private static Singleton instance;   3     privat ...

  7. 【JAVA学习】单例模式的七种写法

    尊重版权:http://cantellow.iteye.com/blog/838473 第一种(懒汉.线程不安全): Java代码   public class Singleton { private ...

  8. Java:单例模式的七种写法<转>

    第一种(懒汉,线程不安全):  1 public class Singleton {   2     private static Singleton instance;   3     privat ...

  9. 温故而知新(java实现)单例模式的七种写法

    第一种(懒汉,线程不安全): Java代码 public class Singleton { private static Singleton instance; private Singleton ...

随机推荐

  1. CentOS7中利用Xshell6向虚拟机本地上传文件

    环境交代 Linux系统:CentOS7, Xshell版本:6 操作步骤 下面我们以一个文件上传来演示用法 第一步 建立连接,这里不多说 在Xshell中点击如下图标,或者直接按 Alt+Ctrl+ ...

  2. redis快照持久化和aof日志持久化

    持久化就是即使断电/重启需要存储的数据不会丢失,即将数据存储在设备中,一般存在硬盘内 redis的持久化有2种方式 :1-rdb快照  2-aof日志,可以通过配置redis.conf文件进行配置 r ...

  3. 如何设置非管理员用户配置特定的IIS站点

    如何设置非管理员用     户配置特定的IIS站点 一.           添加IIS管理服务 二.           启动管理服务 勾选启用远程连接后.点右边的应用 三.           设 ...

  4. Linux Collection:源和更新

    PAS 配置sources.list软件源 参考例子(Debian 9,文件/etc/apt/sources.list): deb https://mirrors.ustc.edu.cn/debian ...

  5. C#基础知识之反射

    http://blog.csdn.net/educast/article/details/2894892 两个现实中的例子:1.B超:大家体检的时候大概都做过B超吧,B超可以透过肚皮探测到你内脏的生理 ...

  6. Kafka集成Kerberos之后如何使用生产者消费者命令

    1.生产者1.1.准备jaas.conf并添加到环境变量(使用以下方式的其中一种)1.1.1.使用Kinit方式前提是手动kinit 配置内容为: KafkaClient { com.sun.secu ...

  7. web框架开发-Ajax

    Ajax简介 向服务器发送请求的4种方式 1.浏览器地址栏,默认get请求2.form表单: get请求 post请求3.a标签,默认get请求 4.Ajax 特点: 1 异步请求 2 局部刷新 方式 ...

  8. springboot操作mongodb

    springboot操作mongodb 采用MongoRepository操作mongodb springboot版本2.1.2.RELEASE 注意的是:在运行应用程序时,会报错OSS Algori ...

  9. golang json 读写配置文件

    package main import ( "encoding/json" "fmt" "os" ) type configuration ...

  10. pybind11 安装

    Prerequisites: $ sudo apt-get install python-dev  (or python3-dev) $ sudo apt-get install cmake $ su ...