单例模式

public class SinglentonEH {
	private static SinglentonEH instance = new SinglentonEH();
	
	private SinglentonEH(){
		
	}
	public static SinglentonEH getInstance(){
		
		return instance;
	}
}

懒汉模式（线程不安全）
实现懒加载，当程序第一次访问单例模式实例时才进行创建，节约资源
线程不安全，在多线程下不能正常工作

public class SinglentonLH {
	
	 /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
	private static SinglentonLH instance = null;
	
	//让构造函数为 private，这样该类就不会被实例化
	private SinglentonLH(){
		System.out.println("-->懒汉式单例模式开始调用构造函数");
	}
	
	/* 静态工程方法，创建实例 */  
	public static SinglentonLH getSinglentonLH(){
		System.out.println("-->懒汉式单例模式开始调用公有方法返回实例");
		if(instance == null){
			System.out.println("-->懒汉式构造函数的实例当前并没有被创建");
			instance = new SinglentonLH();
		}else{
			System.out.println("-->懒汉式构造函数的实例已经被创建");
		}
		System.out.println("-->方法调用结束，返回单例");
		return instance;
	}
	
	/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
    public Object readResolve() {  
        return instance;  
    }  
}

线程安全的懒汉模式

public class SinglentonLHsyn {
	private static SinglentonLHsyn instance= null;
	private SinglentonLHsyn(){
	}
	public static synchronized SinglentonLHsyn getInstance(){
		if(instance == null){
			instance = new SinglentonLHsyn();
		}
		return instance;
	}
}

但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：

双检锁/双重校验锁（DCL，即 double-checked locking）

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

似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。但是，这样的情况，还是有可能有问题的，看下面的情况：在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了，我们以A、B两个线程为例：

a>A、B线程同时进入了第一个if判断

b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();

c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化：

private static class SingletonFactory{           
        private static Singleton instance = new Singleton();           
    }           
    public static Singleton getInstance(){           
        return SingletonFactory.instance;           
    }

实际情况是，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：

登记式/静态内部类

public class Singleton {  
  
    /* 私有构造方法，防止被实例化 */  
    private Singleton() {  
    }  
  
    /* 此处使用一个内部类来维护单例 */  
    private static class SingletonFactory {  
        private static Singleton instance = new Singleton();  
    }  
  
    /* 获取实例 */  
    public static Singleton getInstance() {  
        return SingletonFactory.instance;  
    }  
  
    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
    public Object readResolve() {  
        return getInstance();  
    }  
}

其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的：

public class SingletonTest {  
  
    private static SingletonTest instance = null;  
  
    private SingletonTest() {  
    }  
  
    private static synchronized void syncInit() {  
        if (instance == null) {  
            instance = new SingletonTest();  
        }  
    }  
  
    public static SingletonTest getInstance() {  
        if (instance == null) {  
            syncInit();  
        }  
        return instance;  
    }  
}

补充：采用"影子实例"的办法为单例对象的属性同步更新

public class SingletonTest {  
  
    private static SingletonTest instance = null;  
    private Vector properties = null;  
  
    public Vector getProperties() {  
        return properties;  
    }  
  
    private SingletonTest() {  
    }  
  
    private static synchronized void syncInit() {  
        if (instance == null) {  
            instance = new SingletonTest();  
        }  
    }  
  
    public static SingletonTest getInstance() {  
        if (instance == null) {  
            syncInit();  
        }  
        return instance;  
    }  
  
    public void updateProperties() {  
        SingletonTest shadow = new SingletonTest();  
        properties = shadow.getProperties();  
    }  
}

枚举方法（线程安全）

public enum EnumSingleton {
	INSTANCE;
    public void otherMethods(){
        System.out.println("Something");
    }

如果我们想调用它的方法时，仅需要以下操作：

public class Hello {
    public static void main(String[] args){
        SingletonDemo.INSTANCE.otherMethods();
    }
}

它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化

这种方法虽然很优秀，但是它仍然不是完美的——比如，在需要继承的场景，它就不适用了

使用ThreadLocal实现单例模式

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> tlSingleton =
            new ThreadLocal<ThreadLocalSingleton>() {
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };
    /**
     * Get the focus finder for this thread.
     */
    public static ThreadLocalSingleton getInstance() {
        return tlSingleton.get();
    }
    // enforce thread local access
    private ThreadLocalSingleton() {}
}

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

volatile

public class VolatileSinglenton {
	private volatile static VolatileSinglenton instance= null;
	private VolatileSinglenton(){
		
	}
	public static VolatileSinglenton getInstance(){
		if(instance == null){
			synchronized (VolatileSinglenton.class) {
				if(instance == null){
					instance = new VolatileSinglenton();
				}
			}
		}
		return instance;
	}

volatile关键字的一个作用是禁止指令重排，把instance声明为volatile之后，对它的写操作就会有一个内存屏障（什么是内存屏障？），这样，在它的赋值完成之前，就不用会调用读操作。
注意：volatile阻止的不singleton = newSingleton()这句话内部[1-2-3]的指令重排，
而是保证了在一个写操作（[1-2-3]）完成之前，不会调用读操作（if (instance == null)）。

使用CAS锁实现

public class CASSinglenton {
 /** 利用AtomicReference */
 private static final AtomicReference<CASSinglenton> INSTANCE = new AtomicReference<CASSinglenton>();
 /**
  * 私有化
  */
 private CASSinglenton(){
 }
 /**
  * 用CAS确保线程安全
  */
 public static final CASSinglenton getInstance(){
  for (;;) {
   CASSinglenton current = INSTANCE.get();
            if (current != null) {
                return current;
            }
            current = new CASSinglenton();
            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
 }
 
 public static void main(String[] args) {
  CASSinglenton singleton1 = CASSinglenton.getInstance();
  CASSinglenton singleton2 = CASSinglenton.getInstance();
     System.out.println(singleton1 == singleton2);
 }
}

通过单例模式的学习告诉我们：

1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。

2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。