java单例模式浅析

 单例模式：
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

单例模式有三个要点：

        某个类只能有一个实例；
        必须自行创建这个实例；
        必须自行向整个系统提供这个实例。

普通的单例模式，代码如下
public class Singleton {
      private static Singleton  instance;

      private Singleton() {
          //do something
         System. out.println( "thread id:"+Thread. currentThread().getId());
          try {
            Thread. sleep( 1000);
        }  catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

      public static Singleton getInstance() {
          if ( instance ==  null) {
              instance =  new Singleton();
        }
          return  instance;
    }
}
满足了一个单例模式的定义
但是，当多个线程的情况并且
做了一些工作，简单的说耗时1秒才搞定的情况，上面的单例 类Singleton 就不满足了。
代码继续，小小改造：
public class Singleton {
      private static Singleton  instance;

      private Singleton() {
          //do something
          try {
            Thread. sleep( 1000);
        }  catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

      public static Singleton getInstance(String string) {
          if ( instance ==  null) {
            System. out.println(string);
              instance =  new Singleton();
        }
          return  instance;
    }
}
然后客户端的代码：
public class Test {
      public static void main(String[] args) {
        Thread thread =  new Thread( new Runnable() {
              @Override
              public void run() {
                Singleton singleton1 = Singleton. getInstance();
            }
        });
        thread.start();
        Thread thread1 =  new Thread( new Runnable() {
              @Override
              public void run() {
                Singleton singleton2 = Singleton. getInstance();
            }
        });
        thread1.start();
    }
}
最后输出：
thread id:10
thread id:11
这里解决办法有两种：
先说第一种（饿汉式）：继续改造单例类
public class Singleton {
      private static Singleton  instance= new Singleton();

      private Singleton() {
          //do something
         System. out.println( "thread id:"+Thread. currentThread().getId());
          try {
            Thread. sleep( 1000);
        }  catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

      public static Singleton getInstance() {

          return  instance;
    }
}
客户端代码不动，输出
hread id:10
当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。 如果使用饿汉式单例来设计，则不会出现创建多个单例对象的情况，可确保单例对象的唯一性。
第二种实现方式（懒汉式）：
代码继续调整
public class Singleton {
      private static Singleton  instance;

      private Singleton() {
          //do something
         System. out.println( "thread id:" + Thread. currentThread().getId());
          try {
            Thread. sleep( 1000);
        }  catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

      synchronized public static Singleton getInstance() {
          if ( instance ==  null) {
              instance =  new Singleton();
        }
          return  instance;
    }
}
客户端依旧不变，输出
thread id:11
证明也实现了， 当类被加载时，静态变量instance会被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。 如果使用饿汉式单例来设计，则不会出现创建多个单例对象的情况，可确保单例对象的唯一性。
该单例类在getInstance()方法前面增加了关键字synchronized进行线程锁，以处理多个线程同时访问的问题。那么问题来了，上述代码虽然解决了线程安全问题， 但是每次调用getInstance()时都需要进行线程锁定判断，在多线程高并发访问环境中，将会导致系统性能大大降低。如何既解决线程安全问题又不影响系统性能呢？ 我们继续对懒汉式单例进行改进。事实上，我们无须对整个getInstance()方法进行锁定
再次对单例类进行改变，
public class Singleton {
      private volatile static Singleton  instance;

      private Singleton() {
          //do something
         System. out.println( "thread id:" + Thread. currentThread().getId());
          try {
            Thread. sleep( 1000);
        }  catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

      public static Singleton getInstance() {
          if ( instance ==  null) {
              synchronized(Singleton. class){
                  if ( instance ==  null) {
                      instance =  new Singleton();
                }
            }
        }
          return  instance;
    }
}
客户端依旧不变，输出
thread id:10
由于做了两次判断外加锁，所以都称之为 双重锁，
需要注意的是，如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量instance之前增加修饰符volatile，被volatile修饰的成员变量可以确保多个线程都能够正确处理， 且该代码只能在JDK 1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽Java虚拟机所做的一些代码优化，可能会导致系统运行效率降低，因此即使使用双重检查锁定来实现 单例模式也不是一种完美的实现方式
饿汉式VS懒汉式
      饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多线程访问问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象， 由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。
      懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理好多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间， 这意味着出现多线程同时首次引用此类的机率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响
由于上述两种方式都各有问题， 那就出现另外一种更好的方式呢？

。。。。。。。。。。。。。。。。。

版权原因，完整文章，请参考如下：java单例模式浅析