单例模式

单例模式
●核心作用:保证一个类只有一个实例,并且提供一一个访问该实例的全局访问点。

●常见应用场景:
一Windows的Task Manager (任务管理器)就是很典型的单例模式
windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。
项目中,读取配置文件的类,一般也只有一 个对象。 没有必要每次使用配置文件数据,每次new-个对象去读取。
网站的计数器,一般也是 采用单例模式实现,否则难以同步。
-应用程序的日志应用 , -般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作
, 否则内容不好追加。
数据库连接池的设计-般也是采用单例模式 ，因为数据库连接是一种数据库资源。
-操作系统的文件系统 ,也是大的单例模式实现的具体例子，-个操作系统只能有一个文件系统。
Application也是单例的典型应用( Servlet编程中会涉及到)
-在Spring中 ,每个Bean默认就是单例的,这样做的优点是Spring容器可以管理
-在servlet编程中 ,每个Servlet也是单例
-在spring MVC框架/struts1框架中，控制器对象也是单例

●单例模式的优点:
-由于单例模式只生成一 个实例,减少了系统性能开销,当-个对象的产生需要
比较多的资源时,如读取配置、产生其他依赖对象时 ,则可以通过在应用启动
时直接产生一个单例对象,然后永久驻留内存的方式来解决
单例模式可以在系统设置全局的访问点,优化环共享资源访问,例如可以设计
一个单例类,负责所有数据表的映射处理

●常见的五种单例模式实现方式:
主要:
饿汉式(线程安全,调用效率高。但是,不能延时加载。)
//类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
//方法没有同步，调用效率高！
public class SingletonDemo1 {
 
 //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
 private static SingletonDemo1 instance = new SingletonDemo1(); 
 
 private SingletonDemo1(){
 }
 
 //方法没有同步，调用效率高！
 public static SingletonDemo1  getInstance(){
  return instance;
 }
 
}

懒汉式(线程安全,调用效率不高。但是,可以延时加载。)
lazy load 延迟加载，懒加载，真正用的时候才去加载
资源利用率高了，但是每次调用getInstance都要同步，并发效率低了
public class SingletonDemo2 {
 
 //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
 private static SingletonDemo2 instance; 
 
 private SingletonDemo2(){ //私有化构造器
 }
 
 //方法同步，调用效率低！
 public static  synchronized SingletonDemo2  getInstance(){
  if(instance==null){
   instance = new SingletonDemo2();
  }
  return instance;
 }
 
}

其他:
双重检测锁式(由于JVM底层内部模型原因,偶尔会出问题。不建议使用)

静态内部类式(线程安全,调用效率高。但是,可以延时加载)

枚举单例(线程安全,调用效率高,不能延时加载)

1.测试饿汉式单例模式
public class SingletonDemo1 {
 //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
 private static SingletonDemo1 instance = new SingletonDemo1(); 
 private SingletonDemo1(){
 }
 //方法没有同步，调用效率高！
 public static SingletonDemo1  getInstance(){
  return instance;
 }
 
}

2.测试懒汉式单例模式
public class SingletonDemo2 {
 //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
 private static SingletonDemo2 instance;   
 private SingletonDemo2(){ //私有化构造器
 }
 //方法同步，调用效率低！
 public static  synchronized SingletonDemo2  getInstance(){
  if(instance==null){
   instance = new SingletonDemo2();
  }
  return instance;
 }
 
}

3. 双重检查锁实现单例模式
public class SingletonDemo3 {

  private static SingletonDemo3 instance = null;

  public static SingletonDemo3 getInstance() {
    if (instance == null) {
      SingletonDemo3 sc;
      synchronized (SingletonDemo3.class) {
        sc = instance;
        if (sc == null) {
          synchronized (SingletonDemo3.class) {
            if(sc == null) {
              sc = new SingletonDemo3();
            }
          }
          instance = sc;
        }
      }
    }
    return instance;
  }

  private SingletonDemo3() {

  }
   
}

4.测试静态内部类实现单例模式
 * 这种方式：线程安全，调用效率高，并且实现了延时加载！
public class SingletonDemo4 {
 private static class SingletonClassInstance {
  private static final SingletonDemo4 instance = new SingletonDemo4();
 }
 
 private SingletonDemo4(){
 }
 
 //方法没有同步，调用效率高！
 public static SingletonDemo4  getInstance(){
  return SingletonClassInstance.instance;
 }
 
}

 5.测试枚举式实现单例模式(没有延时加载)
public enum SingletonDemo5 {
 //这个枚举元素，本身就是单例对象！
 INSTANCE;
 //添加自己需要的操作！
 public void singletonOperation(){
 }
 
 
}

 * 测试懒汉式单例模式(如何防止反射和反序列化漏洞)
public class SingletonDemo6 implements Serializable {
 //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
 private static SingletonDemo6 instance; 
 
 private SingletonDemo6(){ //私有化构造器
  if(instance!=null){
   throw new RuntimeException();
  }
 }
 
 //方法同步，调用效率低！
 public static  synchronized SingletonDemo6  getInstance(){
  if(instance==null){
   instance = new SingletonDemo6();
  }
  return instance;
 }
 
 //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
 private Object readResolve() throws ObjectStreamException {
  return instance;
 }
 
}

测试反射和反序列化破解单例模式
public class Client2 {
 
 public static void main(String[] args) throws Exception {
  SingletonDemo6 s1 = SingletonDemo6.getInstance();
  SingletonDemo6 s2 = SingletonDemo6.getInstance();
  
  System.out.println(s1);
  System.out.println(s2);
  
  //通过反射的方式直接调用私有构造器
  Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.bjsxt.singleton.SingletonDemo6");
  Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
  c.setAccessible(true);
  SingletonDemo6  s3 = c.newInstance();
  SingletonDemo6  s4 = c.newInstance();
  System.out.println(s3);
  System.out.println(s4);
 }
}
 //通过反序列化的方式构造多个对象
  FileOutputStream fos = new FileOutputStream("d:/a.txt");
  ObjectOutputStream oos = new ObjectOutputStream(fos);
  oos.writeObject(s1);
  oos.close();
  fos.close();
  
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
  SingletonDemo6 s3 =  (SingletonDemo6) ois.readObject();
  System.out.println(s3);
  
  
 }
}

测试枚举式实现单例模式
public class Client {
 
 public static void main(String[] args) {
  SingletonDemo4 s1 = SingletonDemo4.getInstance();
  SingletonDemo4 s2 = SingletonDemo4.getInstance();
  
  System.out.println(s1);
  System.out.println(s2);
  
  System.out.println(SingletonDemo5.INSTANCE==SingletonDemo5.INSTANCE);
  
  
 }
}

 * 测试多线程环境下五种创建单例模式的效率
public class Client3 {
 
 public static void main(String[] args) throws Exception {
  
  long start = System.currentTimeMillis();
  int threadNum = 10;
  final CountDownLatch  countDownLatch = new CountDownLatch(threadNum);
  
  for(int i=0;i<threadNum;i++){
   new Thread(new Runnable() {
    @Override
    public void run() {
     
     for(int i=0;i<1000000;i++){
//      Object o = SingletonDemo4.getInstance();  //测试静态内部类
      Object o = SingletonDemo5.INSTANCE;   //测试枚举类
     }
     
     countDownLatch.countDown();
    }
   }).start();
  }
  
  countDownLatch.await(); //main线程阻塞，直到计数器变为0，才会继续往下执行！
  
  long end = System.currentTimeMillis();
  System.out.println("总耗时："+(end-start));
 }
}

CountDownLatch
-同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一
个或多个线程一直等待。
countDown（）当前线程调此方法,则计数减一 (建议放在finally里执行)
await(，调用此方法会直阻塞当前线程,直到计时器的值为0）