15.1.单例模式的介绍
单例即单个的实例
- 所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法
- 单例模式有两种方式:饿汉式 和 懒汉式
15.2.单例模式步骤:
- 构造器私有化 ----- 防止外部直接 new 一个对象,造成创建多个对象
- 类的内部创建对象
- 向外暴露一个静态的公共方法
15.3.饿汉式
类加载到内存后,就实例化一个单例,JVM保证线程安全
唯一缺点:不管用到与否,类加载时就完成实例化,存在浪费资源的可能
- 常用写法
public class Hungry_1 {
private static final Hungry_1 INSTANCE = new Hungry_1();
// 构造方法私有化,不被外部实例出来
private Hungry_1() {};
public static Hungry_1 getInstance() {return INSTANCE;}
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Hungry_1.getInstance().hashCode());
}
}).start();
}
}
}
运行结果:线程安全
- 完美写法
public enum Hungry_2 {
INSTANCE;
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Hungry_2.INSTANCE.hashCode());
}
}).start();
}
}
}
运行结果:线程安全,还可以防止反序列化
在这里利用了 枚举 的特性,关于枚举,具体可以看 20.Java之枚举
15.4.懒汉式
使用时才创建对象,但要注意线程安全问题
- 懒汉式-1.0:线程不安全
public class Lazy_1 {
private static Lazy_1 INSTANCE;
// 不被外部实例化
private Lazy_1() {}
public static Lazy_1 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Lazy_1();
}
return INSTANCE;
}
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Lazy_1.getInstance().hashCode());
}
}).start();
}
}
}
运行结果:
因为在多线程的时候,可能都同时进入了
if (INSTANCE == null)
这个条件里,所以创建了多个对象
- 懒汉式-2.0:给当前类上锁 synchronized,线程安全,但是执行效率低
public class Lazy_2 {
private static Lazy_2 INSTANCE;
// 不被外部实例化
private Lazy_2() {}
public static synchronized Lazy_2 getInstance() {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Lazy_2();
}
return INSTANCE;
}
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Lazy_2.getInstance().hashCode());
}
}).start();
}
}
}
运行结果:
关键字
sychronized
获得的锁都是对象锁,而不是代码块的锁.
所以代码中哪个线程先执行sychronized关键字的方法,哪个线程就持有这把锁
在静态方法上加锁synchronized 表示锁定.class类 类级别锁
- 懒汉式-3.0:对锁进行改进,提升效率
public class Lazy_3 {
private volatile static Lazy_3 INSTANCE;
// 不被外部实例化
private Lazy_3() {}
public static Lazy_3 getInstance() {
if (INSTANCE == null) {
synchronized (Lazy_3.class) {
if (INSTANCE == null) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Lazy_3();
}
}
}
return INSTANCE;
}
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Lazy_3.getInstance().hashCode());
}
}).start();
}
}
}
运行结果:
这是方法级别的互斥锁,第一个
if (INSTANCE == null)
是当创建对象后直接返回,第二个if (INSTANCE == null)
目的是当多线程都第一次调用该方法时,可能都同时进入了第一个null条件,这时有了互斥锁也没有用,因为还是会排着队创建对象,所以在进入互斥锁后,还要判断一次是否对象被实例化过
如果方法使用static
修饰,默认锁对象:当前类.class
,关于互斥锁和synchronized概念,可以看 37.Java之线程(单线程、多线程、并发、并行、继承 Thread 类、实现Runnable接口、线程的常用方法、线程的生命周期、线程的同步机制、互斥锁、线程的死锁与释放锁)
关于volatile
关键字,是一个轻量型的同步机制,而synchronized
是重量型的同步机制,可以使底层执行顺序一致
- 懒汉式-4.0:完美解决方案,线程安全
public class Lazy_4 {
// 不被外部实例化
private Lazy_4() {};
private static class LazyHolder {
private final static Lazy_4 INSTANCE = new Lazy_4();
}
public static Lazy_4 getInstance() {
return LazyHolder.INSTANCE;
}
// 测试
public static void main(String[] args) {
// 测试线程是否安全
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Lazy_4.getInstance().hashCode());
}
}).start();
}
}
}
运行结果:
静态内部类方式,JVM保证单例,加载外部类时不会加载内部类,当多线程同时调用时,因为有
final
所以保证了只会创建一个对象
关于final可以看 16.Java之final关键字
15.5.饿汉式 与 懒汉式 区别
- 二者最主要的区别在于创建对象的时机不同:
饿汉式是在类加载时就创建了对象实例
而懒汉式是在使用时才创建 - 饿汉式不存在线程安全问题,懒汉式存在线程安全问题
- 饿汉式存在浪费资源的可能,因为如果程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用时才创建,就不存在这个问题
- 在 javaSE 标准类中,java.lang.Runtime 就是经典的单例模式