Java单例设计模式

单例设计模式：
在某个系统中，使用一定的方法使得一个类只能实例化一个对象。

实现代码：

/*
 * 单例设计模式
 * 饿汉式
 */
public class SingleInstanceTest1 {
	public static void main(String[] args) {
		Bank b1 = Bank.getInstance();
		Bank b2 = Bank.getInstance();
		System.out.println(b1==b2); // true
	}
}

class Bank {
	// 1.私有化构造器
	private Bank() {
	}

	// 2.实例化当前对象
	// 4.静态方法只能访问静态的属性，所以实例化对象也是静态的
	private static Bank bank = new Bank();

	// 3.利用静态方法返回实例化对象
	public static Bank getInstance() {
		return bank;
	}
}

/*
 * 单例模式
 * 懒汉式
 */
public class SIngleInstanceTest2 {
	public static void main(String[] args) {
		Order o1 = Order.getInstance();
		Order o2 = Order.getInstance();
		System.out.println(o1==o2);
	}
}

class Order {
	// 1.私有化构造器
	private Order() {
	}

	// 2.声明当前类对象，但是不初始化
	// 4.静态方法只能访问静态属性
	private static Order instance = null;

	// 3.类的静态方法返回对象实例
	/*
	 * 这种写法是线程不安全的
	 */
	public static Order getInstance() {
		if (instance == null) {
			instance = new Order();
		}
		return instance;
	}

}

饿汉式和懒汉式的区别：

• 饿汉式：加载时间过长；是线程安全的。
• 懒汉式：延迟对象的创建，但是上面的写法是线程不安全的，可以通过多线程改写为线程安全的。

懒汉式改写：

/**
 * @author panghu
 * @description 线程安全的懒汉式
 * @create 2021-01-06-16:13
 */
public class SingleInstanceTest3 {
    public static void main(String[] args) {
        Order2 o1 = Order2.getInstance();
        Order2 o2 = Order2.getInstance();
        System.out.println(o1 == o2);
        
    }
}

class Order2 {
    private static Order2 o = null;

    private Order2() {
    }


    public static Order2 getInstance() {
        // 方式一：效率较低
        /*synchronized (Order2.class) {
            if (o == null) {
                o = new Order2();
            }
            return o;
        }*/

        // 方式二：效率相对较高
        if (o == null) {
            synchronized (Order2.class) {
                if (o == null) {
                    o = new Order2();
                }
            }
        }
        return o;
    }
}

单例模式应用场景：

• 网站计数器
• 应用程序的日志应用
• 数据库连接池
• 加载配置文件的类