线程安全的单例模式

单例模式1：

package synchro;

public class Singleton {
    private Singleton(){}
    private static Singleton instance;
    public static Singleton getInstance(){
        if(instance==null){
             instance=new Singleton();
             return instance;
        }
        return instance;
    }
    public static void main(String[] args) {
        for(int i=0;i<1000;i++){
            Thread t=new GetClassInfo();
            t.setName("线程"+i);
            t.start();
        }
    }
}

class GetClassInfo extends Thread{

    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(getName()+"获取单例模式："+Singleton.getInstance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第一种singleton是比较常用的一种单例模式，如果同时有多个线程一起获取这个单例对象的话，可能会出现问题。
1000个线程访问这个对象的结果：
线程2获取单例模式：synchro.Singleton@151574b
线程1获取单例模式：synchro.Singleton@151574b
线程0获取单例模式：synchro.Singleton@151574b
线程3获取单例模式：synchro.Singleton@1d2052b
线程4获取单例模式：synchro.Singleton@1187984
线程6获取单例模式：synchro.Singleton@151574b
线程5获取单例模式：synchro.Singleton@151574b
线程7获取单例模式：synchro.Singleton@151574b
线程10获取单例模式：synchro.Singleton@151574b
可以看到线程3和4分别获取了不同的实例，所以这个单例的写法有缺点。

单例模式2：

package synchro;


public class Singleton2 {
    private Singleton2(){}
    private static Singleton2 instance=new Singleton2();
    public static Singleton2 getInstance(){
        return instance;
    }
    public static void main(String[] args) {
        for(int i=0;i<1000;i++){
            Thread t=new GetClassInfo2();
            t.setName("线程"+i);
            t.start();
        }
    }
}
class GetClassInfo2 extends Thread{

    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(getName()+"获取单例模式："+Singleton2.getInstance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

饿汉模式：
用饿汉模式试了上万遍，没出现不同实例的问题，除了类加载后就创建对象外，这个难道是不会出现线程安全问题的单例模式吗？

单例模式3：

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

sychronized修饰方法：试了上万次，也没有发现出现多个实例的问题。。

单例模式4：

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

使用synchronized代码块包裹new实例的部分，自己用循环一共测试了2万遍，没有发现出现不同实例的情况。

单例模式5：

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

用volatile修饰静态实例，这个没有测试，网上说这个方法是最好的一种写法。需要用好的办法证明一下。

总结：
除了用第一种懒汉单例模式进行测试出现了多个实例的情况，其他几种各测试了上万次（用循环），基本没有出现多个实例的情况。由于本人工作经验才4个月，又是通过培训中心培训出来的，所以技能肯定有所欠缺，麻烦看官能够指出我的错误。。