java 单例模式

单例模式有以下特点：
1.单例类只能有一个实例（该类只能有一个实例）
2.单例类必须自己创建实例
3.单例类必须给所有其他对象提供这一实例
计算机系统中，如线程池、缓存、日志对象、驱动程序等被设置成单例。在多线程环境下，可能有一些同步问题。
如下代码所示：

public class TestStream {
     private String name;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     } 
     //该类只能有一个实例
     private TestStream(){}    //私有无参构造方法
     //该类必须自行创建
     //有2种方式
     /*private static final TestStream ts=new TestStream();*/
     private static TestStream ts1=null;//懒汉单例模式
     //这个类必须自动向整个系统提供这个实例对象
     public static TestStream getTest(){//这里用的是懒汉单例模式
         if(ts1==null){
             ts1=new TestStream();
         }
         return ts1;
     }
     public void getInfo(){
         System.out.println("output message "+name);
     }
 }
public class TestMain {
     public static void main(String [] args){
         TestStream s=TestStream.getTest();
         s.setName("张孝祥");
         System.out.println(s.getName());
         TestStream s1=TestStream.getTest();
         s1.setName("张孝祥");
         System.out.println(s1.getName());
         s.getInfo();
         s1.getInfo();
         if(s==s1){
             System.out.println("创建的是同一个实例");
         }else if(s!=s1){
             System.out.println("创建的不是同一个实例");
         }else{
             System.out.println("application error");
         }
     }
 }

运行结果：　
张孝祥　　
张孝祥　　
output message 张孝祥　　
output message 张孝祥　　
创建的是同一个实例
懒汉单例模式:默认不自动实例化，等用的时候根据当前情况实例化

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

饿汉单例模式：在类第一次加载的时候强制实例化

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

单例模式的线程同步问题：
两个线程，一个发现变量是null,准备创建变量，第二个也发现变量是null,创建变量，就会造成在一个JVM中有多个单例类型的实例。
解决线程安全的方案：
1.使用synchronized方法对getInstance()方法进行同步

public class Singleton{
  private static Singleton instance = null;
  private Singleton(){}
  public synchronized  static Singleton getInstance(){
    if(instance == null)  //mark1
        return new Singleton();//mark2
     else
        return instance;
}
}

2.双重锁
但是用synchoronized会导致性能下降，我们想要的只是mark1和mark2的同步，所以可以不把synchronized加在方法上，而是加在代码块里

public class Singleton{
  private static volatile Singleton instance;
  
  private static Singleton(){}
  
  public static Singleton getSingleton(){
      if(instance == null){//mark1
        synchronized(Singleton.class){
            if(instance == null)//mark2
  return new Singleton();
             return instance;
}
return instance;
}    

}
}

这里用了两个判断，原因：如果两个线程同时到达mark1处，synchronized可以保证线程不同时进行，但两个线程会一个个执行，所以还要在synchronized代码块中再次判断，防止创建两个。
这个也叫作双重锁。
3.使用静态内部类
这种方法拥有单例、延迟创建（参见饿汉模式）和线程同步的优点，利用静态内部类来实现

public class Singleton{
    private static Singleton(){}
    
    private static class Lazyholder{
     private static final Singleton instance = new Singleton();
}

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

当类被加载时，由于没有static代码，所以不会有操作。当第一次执行getSingleton()方法时，内部静态类会被加载，创建外部单例类实例，在内部类加载过程中，静态类只会被加载一次，static属性和static初始化块的执行是串行的，这就保证了不会有两个线程同时new Singleton()