(153条消息) 解决线程安全问题&&单例模式_Master_hl的博客-CSDN博客

饿汉式

在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建

直接实例化饿汉式（简洁直观）  

特点：构造器私有化、自行创建且用静态变量保存、向外提供这个实例、强调单例用final修饰

public class Singleton1{
    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){

    }
}

枚举类型（最简洁）

表示该类型的对象是有限的几个，我们可以限定为一个，那么就成了单例 

public enum Singleton2{
    INSTANCE
}

静态代码块（适合复杂实例化）

single.properties文件注意放在src目录下 

info=zhangsan

public class Singleton3{
    public static final Singleton3 INSTANCE;
    private String info;
    private Singleton3(String info){
        this.info=info;
    }
    
    static{
        try{
        Properties pro=new Properties();
        pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));   
        INSTANCE=new Singleton3(pro.getProperty("info"));
        }catch(Excepetion e){
            throw new RuntimeException(e);
        }
    }
}

 注意生成getset方法和toString方法

public class TestSingleton3{
    public static void main(String[] args){
        Singleton3 s=new Singleton3.INSTANCE;
        System.out.println(s);
    }
}

懒汉式

延迟创建这个实例对象

特点：构造方法私有化、用静态变量保存这个唯一实例、提供一个静态方法获取这个实例对象

public class Singleton4{
    private static Singleton4 instance;
    private Singleton4(){}

    public static Singleton4 getInstance(){
        if(instance==null){
            try{
                thread.sleep(100);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            instance=new Singleton4();   
        }
        return instance;
    }
}

public class TestSingleton4{
    public static void main(String[] args) throws InterruptedException{
        Callable<Singleton4> c=new Callable<Singleton4>(){
            @Override
            public Singleton4 call() throws Exception{
                return Singleton4.getInstance();
            }
        };
        ExecutorService es=Executors.newFixedThreadPool(2);
        Future<Singleton4> f1=es.submit(c);
        Future<Singleton4> f2=es.submit(c);

        Singleton4 s1=f1.get();
        Singleton4 s2=f2.get();
        System.out.println(s1==s2);//false
    }
}

上面出现线程不安全问题（适合单线程），所以才会产生false

public class Singleton5{
    private static Singleton5 instance;
    private Singleton5(){}

    public static Singleton5 getInstance(){
        //第一个if提高效率问题
        if(instance==null){
            //解决线程安全问题
            Synchronized(Singleton5.class){
                if(instance==null){
                try{
                    thread.sleep(100);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                instance=new Singleton5();   
                }
            }
        }
        return instance;
    }
}

修改了，解决了线程安全问题，并且提高了效率问题（适合多线程）

静态内部类（适合多线程）

public class Singleton6{
    private Singleton6(){}

    private static class Inner{
        private static final Singleton6 INSTANCE=new Singleton6();
    }

    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }

说明：在内部类被加载和初始化时，才创建INSTANCE实例对象

静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的

因为是在内部类加载和初始化时，创建的，因此是线程安全的