java设计模式 - 单例模式(干货)

  深度讲解23种设计模式,力争每种设计模式都刨析到底。废话不多说,开始第一种设计模式 - 单例。

  作者已知的单例模式有8种写法,而每一种写法,都有自身的优缺点。

1,使用频率最高的写法,废话不多说,直接上代码

/**
* @author xujp
* 饿汉式 静态变量 单例
*/
public class Singleton  implements Serializable {

private static final long serialVersionUID = 1L;

private final static Singleton instance = new Singleton();

private Singleton(){}
public static Singleton getSingleton(){
return instance;
}

private String tmp;

public String getTmp() {
return tmp;
}

public void setTmp(String tmp) {
this.tmp = tmp;
}
}

 new Singleton() 的执行时机 - > 类加载时

 这种方法是最通用的单例实现,也是笔者常用的,但这种方法有一些缺点

 1)内存方面,如果单例中的内容很多,会在类加载时,就占用java虚拟机(这里专指HotSpot)空间。

 2)序列化以及反序列化问题,如果这个单例类实现了序列化接口Serializable,那么可以通过反序列化来破坏单例。

 通过反序列化破坏单例:

public static void main(String[] args) throws IOException, ClassNotFoundException {
Singleton singleton=null;
Singleton singletonNew=null;

singleton=Singleton.getSingleton();

singleton.setTmp("123");

ByteArrayOutputStream bos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bos);
oos.writeObject(singleton);

ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois=new ObjectInputStream(bis);
singletonNew= (Singleton) ois.readObject();

singleton.setTmp("456");

System.out.println(singletonNew.getTmp());
System.out.println(singleton.getTmp());
System.out.println(singleton==singletonNew);
}

  输出结果为:

  false

  123

  456

  从这里例子中我们可以看到单例被破坏了,也就不能保证单例的唯一性。

2,第一种方案的变种

/**
* @author xujp
* 饿汉式 静态代码块 单例
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private final static Singleton instance;

static {
instance = new Singleton();
}

private Singleton(){}

public static Singleton getSingleton(){
return instance;
}
}

 其实这种方法和第一种方法,几乎没有什么区别。

3,线程不安全的写法 - 1

/**
* @author xujp
* 懒汉式 单例 线程不安全
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private static Singleton instance;

private Singleton(){}

public static Singleton getSingleton(){
if(null == instance) {
instance = new Singleton();
}
return instance;
}
}

 这种写法,虽然实现了懒加载,节省了内存,但线程不安全。

 假设有两个线程,并假设 new Singleton() 耗时2秒,0秒时,线程1执行new,然后去等待,1秒时,线程2执行if判断,

这个时候判断结果就是true,这样就会出现两个Singleton对象,完美破坏掉了单例。

4,线程不安全的写法 - 2

/**
* @author xujp
* 懒汉式 单例 代码块加锁 线程不安全
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private static Singleton instance;

private Singleton(){}

public static Singleton getSingleton(){
if(null == instance) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}

 这种写法虽然在new Single()时,增加了锁,但这个锁,并不能阻止单例被破坏,所以这种写法错误。

 同样,假设有两个线程,线程1执行到synchronized时,线程2执行if判断,这个时候判断结果就是true,

这样就会出现两个Singleton对象,同样完美破坏掉了单例。

5,线程安全,但资源消耗过多

/**
* @author xujp
* 懒汉式 单例 方法加锁 线程不安全
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private static Singleton instance;

private Singleton(){}

synchronized public static Singleton getSingleton(){
if(null == instance) {
instance = new Singleton();
}
return instance;
}
}

 这种写法确实能够保证线程安全,但synchronized属于方法锁,而方法锁回锁定对象,导致性能低下。

6,相对完美的写法 - 1

/**
* @author xujp
* 懒汉式 单例 代码加锁 线程安全
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private static volatile Singleton instance;

private Singleton(){}

public static Singleton getSingleton(){
if(null == instance) {
synchronized (Singleton.class) {
if(null == instance) {
instance = new Singleton();
}
}
}
return instance;
}
}

双检查这种写法,在多线程问题上,属实没有问题,synchronized也没有锁定对象,而且也优化了锁资源开销问题。

7,相对完美的写法 - 2

/**
* @author xujp
* 懒汉式 单例 静态内部类 线程安全
*/
public class Singleton implements Serializable {

private static final long serialVersionUID = 1L;

private static class SingletonInstance{
private static Singleton instance = new Singleton();
}
private Singleton(){}

public static Singleton getSingleton(){
return SingletonInstance.instance;
}
}

使用静态内部类来实现单例,主要借助JVM机制,静态内部类初始化的时候,其他线程无法进入,从而避免了多线程问题。

而且静态内部类不会直接初始化,从而减轻了内存开销。

8,完美写法

/**
* @author xujp
* 枚举实现单例
*/
public enum Singleton {
SINGLETON;
private String property = "hello ca fe ba be";
public void doSomeThing(){
System.out.println(property);
}
}

这种写法用枚举解决多线程问题,而且时唯一一种解决序列化问题的写法。

改写法出自大神Josh Bloch,如果有兴趣可以去查看一下他的资料。

总结:

1,1和2写法虽然是饿汉式,没有实现懒加载,也没有100%保证单例,但却是我们最常用的写法,

 因为,单例对象通常占用空间不会很大,而且程序都由程序员自己管理,被反序列的危险性不高。

2,3和4写法实现了懒加载,减少了内存开销,但不能使用,因为多线程开发,是我们常见的开发。

3,5写法使用了方法锁,会将对象锁住,会导致性能大打折扣。

4,6和7写法,懒加载、性能都非常完美,缺点只有一个,那就是序列化问题。

5,8写法,笔者暂未发现缺点。

实际开发中,无论是使用1、2写法,还是使用6、7写法,亦或是使用8写法,都是可以的。

 


  

 

posted @ 2020-02-27 22:57  江流大海_浮萍如尘  阅读(...)  评论(...编辑  收藏