单例模式

定义

确保一个类只有一个实例，并提供一个全局访问点。

最简单的单例模式

设计要点：
1.构造方法是私有的
2.有一个属于类的类对象
3.有一个公有的属于类的返回对象的方法（在该方法里调用构造方法）

public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        if(singleton==null) {
            singleton = new Singleton();
            System.out.println("最简单的单例模式");
            return singleton;
        }
        return singleton;
    }
}

测试代码：

public class MainTest {
    public static void main(String arg[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
    }
}

但是这样的设计当碰到多线程是就会被破环了。例如：

public class MyThread extends Thread{
        @Override
        public void run(){
            for(int i=0;i<100;i++){
                Singleton.getInstance();
            }
        }
}

public class MainTest {
    public static void main(String arg[]){
        try{
          for(int i=0;i<20;i++){
              new MyThread().start();
          }
        }catch(Exception e){}
    }
}

加了互斥锁的单例模式

这样即使是在多线程下它仍然是单例的

public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        synchronized (Singleton.class){
            if(singleton==null) {
                singleton = new Singleton();
                System.out.println("最简单的单例模式");
                return singleton;
            }
            return singleton;
        }

    }
}

懒汉静态内部类的方式：(没有一行代码是多余的)

public class singleton(){
     //静态内部类..
private私有的，保证别人不能修改，static保证全局唯一性。
    private static class LayHolder{
//防止内部误操作
           private static final Singleton INSTANCE=new Singleton()
    }
   private Singleton(){}
//final确保别人不能覆盖
   private static final getInstance(){
       return Layholder.INSTANCE
    }
}