单例模式:Singleton Pattern

对象类型的创建只有一个实例，单例类必须自己创建自己的唯一实例。
优点：1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

方式一：

[java]package com.proliu.designPatterns.single;
/**

  • @author duliu
  • 没有加锁，执行效率会提高, 类加载时就初始化，浪费内存。
  • /
    public class SingleObject {

private static SingleObject singleObject = new SingleObject();

public SingleObject(){

}

public static SingleObject getInstance(){
return singleObject;
}

public void outMsg(){
System.out.println(“Hello, This is Single Object.” + this.getClass().hashCode());
}
}[/java]

方式二：

[java]package com.proliu.designPatterns.single;

/**

  • @author duliu
  • 这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized.
  • /
    public class SingleObjectTwo {

private static SingleObjectTwo singleObjectTwo ;

public SingleObjectTwo(){

}

public static SingleObjectTwo getInstance(){
if(singleObjectTwo == null){
singleObjectTwo = new SingleObjectTwo();
}

return singleObjectTwo;
}

public void outMsg(){
System.out.println(“Hello, This is Single Object Two.” + this.getClass().hashCode());
}
}[/java]

方式三：

[java]package com.proliu.designPatterns.single;

/**
*

  • @author duliu
  • 第一次调用才初始化，避免内存浪费, 必须加锁 synchronized 才能保证单例，但加锁会影响效率。
  • /
    public class SingleObjectThree {

private static SingleObjectThree singleObjectThree ;

public SingleObjectThree(){

}

/**

  • 同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，
  • 在多线程访问的时候，同一时刻只能有一个线程能够用synchronized 修饰的方法 或者 代码块。
  • @return
  • /
    public static synchronized SingleObjectThree getInstance(){
    if(singleObjectThree == null){
    singleObjectThree = new SingleObjectThree();
    }

return singleObjectThree;
}

public void outMsg(){
System.out.println(“Hello, This is Single Object Three.” + this.getClass().hashCode());
}
}[/java]

方式四：

[java]package com.proliu.designPatterns.single;

/**

  • @author duliu
  • 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
  • /
    public class SingleObjectFour {

/**

  • 用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值
  • /
    private volatile static SingleObjectFour singleObjectFour ;

public SingleObjectFour(){

}

public static SingleObjectFour getInstance(){
if(singleObjectFour == null){
synchronized (SingleObjectFour.class){
if(singleObjectFour == null)
singleObjectFour = new SingleObjectFour();
}
}

return singleObjectFour ;
}

public void outMsg(){
System.out.println(“Hello, This is Single Object Four.” + this.getClass().hashCode());
}
}[/java]

方式五：

[java]package com.proliu.designPatterns.single;

/**

  • @author duliu
  • 通过静态内部类来实现类的实例化
  • /
    public class SingleObjectFive {

private static class SingleObjectHolder{
private static final SingleObjectFive INSTANCE = new SingleObjectFive();
}

public SingleObjectFive(){

}

public static final SingleObjectFive getInstance(){
return SingleObjectHolder.INSTANCE ;
}

public void outMsg(){
System.out.println(“Hello, This is Single Object Five.” + this.getClass().hashCode());
}
}[/java]

方式六：

[java]package com.proliu.designPatterns.single;

/**

  • @author duliu
  • 参与枚举模式
  • /
    public enum SingleObjectSix {

INSTANCE;

public void outMsg(){
System.out.println(“Hello, This is Single Object Six.” + this.getClass().hashCode());
}
}[/java]