/**
* 面试:谈谈你对单例模式的认识?
* 对象单例设计:(设计类时保证类的实例在内存中只有一份)
* 1)内部设计实现(对类自身进行设计)
* 2)外部设计实现(对类的对象提供一种池)
*/
单例模式的设计目的
单例模式保证一个类仅有一个实例,并提供一个访问它的全局访问点;
(1)基于全局访问点的思想,很容易想到定义全局或者静态对象,但是这样不能保证该类只声明一个静态对象,并没有实现仅有一个对象的思想;
(2)单例模式设计方式
• 将类的构造函数写在私有下;
• 定义一个静态的指针指向该类唯一的对象;
• 定义一个公有下返回该对象的静态方法
package com.java.oop.instance;
class Single2 {
private Single2() {
System.out.println("调用了Single2()......");
}
private static Single2 instance;
public static Single2 getInstance() {
if (instance == null) {
instance = new Single2();
}
return instance;
}
}
public class Test2 {
public static void main(String[] args) throws Exception {
show();
}
private static void show() throws Exception {
// 局部内部类
class Task implements Runnable {
@Override
public void run() {
Single2.getInstance();
}
}
Thread t1 = new Thread(new Task());
Thread t2 = new Thread(new Task());
Thread t3 = new Thread(new Task());
t1.start();
t2.start();
t3.start();
}
}
这种设计在多线程情况下不安全
调用了Single2()…
会随机出现 1,2,3次
所以我们要对其优化
单例模式优化之一
package com.java.oop.instance;
/**方案1:线程安全的单例设计 大对象,并发访问少 */
//锁加双重验证 线程安全
class Single {
private Single() {
System.out.println("-------");
}
private static volatile Single instance;
public static Single getInstance() {
if (instance == null) {
synchronized (Single.class) {
if (instance == null) {
instance = new Single();
}
}
}
return instance;
}
}
单例模式优化之二
/**方案2:线程安全的单例设计 小对象,频繁访问 */
//线程安全 无阻塞
//缺陷:可能占用资源比较多,尤其是大对象
//类加载时 对象创建且 只创建一次
class Singleton{
private Singleton(){ }
private static Singleton instance = new Singleton();
private static Singleton getInstance() {
return instance;
}
}
单例模式优化之三
/**方案4: 大对象 频繁用(高并发 大量访问)*/
class Singleton04{
private Singleton04(){ }
//通过内部类实现属性的延迟初始化(懒加载 延迟加载)
static class Inner{
private static Singleton04 instance = new Singleton04();
}
private static Singleton04 getInstance() {
return Inner.instance;
}
public static void show(){}
}