java集群优化——多线程下的单例模式

 在最初学习设计模式时，我为绝佳的设计思想激动不已，在以后的工程中，多次融合设计模式，而在当下的设计中，我们已经觉察出了当初设计模式的高瞻远瞩，但是也有一些不足，需要我们去改进，有人说过，世界上没有绝对的事，当然，再简单的事情，环境变了，也会发生变化，今天和大家一起分享在多线程下单例模式的优化。

1，传统

首先，我们回顾下传统的单例（懒汉式）是如何工作的：

 

[java] view plain copy

1. public class SingletonClass{  
2.     private static SingletonClass instance=null;  
3.     public static SingletonClass getInstance()  
4.     {  
5.         if(instance==null)  
6.         {  
7.                instance=new SingletonClass();  
8.         }  
9.         return instance;  
10.     }  
11.     private SingletonClass(){  
12.     }  
13. }  

 

 

我们不难看出，在多线程执行时，普通的代码会带了困恼，大家看多线程代码运行时的图片：

 

2，双重锁

我们看到线程1和线程2都执行了代码②，我们得到的并不是一个单例的对象，而是多个对象。针对这些我们进行了同步的优化。

 

[java] view plain copy

1. public static class Singleton{  
2.     private static Singleton instance=null;  
3.     private Singleton(){  
4.         //do something  
5.     }  
6.     public static Singleton getInstance(){  
7.         if(instance==null){  
8.             synchronized(Singleton.class){  
9.                 if(null==instance){  
10.                     instance=new Singleton();  
11.                 }  
12.             }  
13.         }  
14.         return instance;  
15.     }  
16. }  

我们在看看这种代码的多线程运行图：

 

大家看，③只执行了一次，不仅仅是它被同步机制保护了，而且是进行了双重判定，这样保证多线程下单例模式的正常运行。

3，枚举

在jdk1.5之后，java注意到这一细节，在创建单例应用时，我们可以利用枚举类型完成我们的工作，并且他是线程安全的。

源码：

 

[java] view plain copy

1. public enum SingletonEnum  
2. {  
3.     INSTANCE;  
4.     private String name;  
5.     publicString getName()  
6.     {  
7.        returnname;  
8.     }  
9.      publicvoid setName(String name)  
10.     {  
11.        this.name = name;  
12.     }  
13.  }  

    这种优化，使我们更优雅地适用代码，但是也带来了一定的问题，就是我们对对象的类型有了模糊的概念，所以在工作中，还是建议保留双锁模式，对一些工具类则可以采取枚举类型优化，简化我们的代码与逻辑。

 

 

总结：

        细节的优化，就像雕琢一件艺术品，我们接触的高人越多，这样的思想就越浓厚，所以，我们常常判断一个人事怎么的品格与素质，通过他接触的人，朋友就可以推测出来，而计算机内，也是如此，我们接触的优秀框架多了，自己自然就是优秀的设计师！

转载于:https://my.oschina.net/vshcxl/blog/730090