有些东西学完就忘,怎么办呢?
还能咋办,忘了再学呗!
前言
我们为什么需要单例模式呢?每次都new一个对象不行吗?
根据我这个快要毕业的、没有开发经验的菜鸟来看,内存是有数的,并不是无限的,所以单例模式是为了尽可能的节约资源,只有一个对象和频繁的创建对象,孰优孰略想想就知道。
饿汉式
概念就是很神奇,一眼下去是个懵逼的词,等你弄懂了又发现这个词确实还挺形象准确。
怎么实现单例?肯定不能随便让你new一个对象,把构造器私有化。那怎么获取对象呢?自然是暴露出来一个方法能够获取这个对象。首先我们来看这个饿汉式的实现方式。什么是饿汉式呢?就是当类加载完毕,对象就创建好了,不管你用不用,先给你创建上。我们看代码:
public class TaskManageHungry {
private static TaskManageHungry taskManageHungry = new TaskManageHungry();
//构造器私有
private TaskManageHungry() {
System.out.println("执行构造器===>");
}
//获取这个对象的方法
public static TaskManageHungry getInstance(){
return taskManageHungry;
}
//测试这个单例模式
public static void main(String[] args) {
TaskManageHungry taskManageHungry1 = TaskManageHungry.getInstance();
TaskManageHungry taskManageHungry2 = TaskManageHungry.getInstance();
TaskManageHungry taskManageHungry3 = TaskManageHungry.getInstance();
System.out.println(taskManageHungry1);
System.out.println(taskManageHungry2);
System.out.println(taskManageHungry3);
}
}
这样我们就实现了这个饿汉式的单例模式,每次都是同一个对象,我们可以运行看看。
但是呢,这样虽然实现了单例模式,可它还是有点问题。怎么说呢,我们先回归一下单例模式的初心——节约资源。那假如这个对象我用的次数并不多,而且系统启动后很长时间我才能用得上这个对象,那它直接创建出来,很长时间不被使用,被它占用的那点内存不就浪费了吗?所以这就又引出了懒汉式单例。
懒汉式
什么是懒汉式呢?就是我并不急着创建这个对象,只有当它第一次被调用的时候再创建这个对象。我们还是直接看代码
public class TaskManageLazy {
private TaskManageLazy(){
System.out.println("懒汉式构造器执行");
}
private static TaskManageLazy taskManageLazy;
//获取实例
public static TaskManageLazy getInstance(){
if (taskManageLazy == null) {
taskManageLazy = new TaskManageLazy();
}
return taskManageLazy;
}
}
我们在获取对象的方法里加一个判断,这样就实现了懒汉式单例。没人用的时候,它就是个null,有人调用了,才会创建对象。
但是这样又出现了新的问题,比如我有十个线程,同时调用这个对象,十个线程都是第一次调用,那岂不是就又创建了好几个对象,单例模式就被破坏了,我们来看看这个多线程情况下会出现什么样的结果。
public static void main(String[] args) {
//测试多线程下
for (int i = 0; i < 10; i++) {
new Thread(() -> System.out.println(TaskManageLazy.getInstance())).start();
}
}
开十个线程来调用,我们来看运行结果。
这说明我们的懒汉式单例还是不够完善,那怎么才能在多线程情况下也能实现单例模式呢?当然是上锁。
public class TaskManageLazy {
private TaskManageLazy(){
System.out.println("懒汉式构造器执行");
}
private static TaskManageLazy taskManageLazy;
//获取实例
public static TaskManageLazy getInstance(){
synchronized (TaskManageLazy.class) {
if (taskManageLazy == null) {
taskManageLazy = new TaskManageLazy();
}
}
return taskManageLazy;
}
}
这样锁起来确实可以保证线程安全,但是我们想一下,只有第一次执行的时候才需要加锁来创建对象。如果要是这样写,那我每次获取实例都要锁起来,不管有没有对象都要锁起来,假如我有一百个线程要获取这个对象,那这一百个线程岂不是要排队等待着一个个获取。所以,我们还要把它改造一下,没有对象的时候加锁,有对象了就直接返回。
public class TaskManageLazy {
private TaskManageLazy(){
System.out.println("懒汉式构造器执行");
}
private static TaskManageLazy taskManageLazy;
//获取实例
public static TaskManageLazy getInstance(){
if (taskManageLazy == null){
synchronized (TaskManageLazy.class) {
if (taskManageLazy == null) {
taskManageLazy = new TaskManageLazy();
}
}
}
return taskManageLazy;
}
}
这种方式就叫做双重检查锁。检查了两次null可不就是双重嘛。
了解到这里其实也还行,不过我们能不能更深入一点呢?这样就真的安全了吗?假如有人用反射破坏了这个单例怎么办呢?有没有一种办法一劳永逸呢?
这些事情,就以后再聊吧。