通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

1.懒汉式

public class Singleton1 {
    private static Singleton1 singleton1 = null;
    private Singleton1(){}
    public static Singleton1 newInstance() {
        if (singleton1 == null){
            singleton1 = new Singleton1();
        }
        return  singleton1;
    }
}

2.饿汉式

public class Singleton2 {
    private static Singleton2 singleton2 = new Singleton2();
    private Singleton2(){}
    public static Singleton2 newSingleton(){
        return singleton2;
    }
}

3.懒汉式改

//序列化
public class Singleton3 implements Serializable {
    // volatile保证变量一致性
    private volatile static Singleton3 singleton3 = null;
    private Singleton3(){
        //防止反射调用私有方法
        if(singleton3 != null){
            throw new RuntimeException("此类对象为单例模式，已被实例化");
        }
    }

    public static Singleton3 newInstance(){
        //为了避免每次都加锁，避免了一定的加锁的开销
        if(singleton3 == null) {
            //多线程
            synchronized (singleton3) {
                if (singleton3 == null) {
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }
}

说明：

  1. 外层singleton3 == null，为了避免每次都加锁，避免了一定的加锁的开销；

  2. 把类的构造函数定义为私有private，外部便无法通过new生成对象。