Java设计模式之单例模式的学习

本篇是本人的第二篇博客
旨在记录本人对于Java设计模式之单例模式的学习和理解，也希望本篇可以对一些正在学习的小伙伴起到一些帮助
单例模式(singleton)的特点：
1、单例模式有且仅有一个实例；
2、单例类必须为自己创建一个实例对象；
3、单例类必须为其他类提供自己的实例对象。
一句话概括就是单例模式确保一个类只有一个实例对象，并向整个系统提供这个实例。
单例模式常见的实现方式：
饿汉式

public class Mgr01 {private static final Mgr01 INSTANCE = new Mgr01();private Mgr01(){};public static Mgr01 getInstance(){return INSTANCE;}public static void main(String[] args) {Mgr01 m1 = Mgr01.getInstance();Mgr01 m2 = Mgr01.getInstance();System.out.println(m1 == m2);}
}

代码执行结果：

true

类加载到内存后，就实例化一个单例，JVM保证线程安全，这是最常用也最推荐的一种实现方式
缺点是：不论这个类是不是需要用到，他在JVM对Class进行装载的时候就会实例化一个对象出来

饿汉式的另一种写法

public class Mgr02 {private static final Mgr02 INSTANCE;static {INSTANCE = new Mgr02();}private Mgr02(){};public static Mgr02 getInstance(){return INSTANCE;}}

这里其实和Mgr01是一样的写法，只是将类的实例化放到了静态代码块中

懒汉式

public class Mgr03 {private static Mgr03 INSTANCE;private Mgr03(){ }public static Mgr03 getInstance(){if(INSTANCE == null){try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Mgr03();}return INSTANCE;}public static void main(String[] args) {for (int i = 0;i < 10;i++) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Mgr03.getInstance().hashCode());}}).start();}}
}

代码执行结果：

这里是打印的Mgr03的hashcode()的值，很明显，他们并不是同一个对象
这种写法的懒汉式，虽然达到了在使用时才会初始化实例对象的目的，但是在多线程的情况下，并不能保证线程的安全性

通过加锁来保证懒汉式的安全性

public class Mgr04 {private static Mgr04 INSTANCE;private Mgr04(){ }public static synchronized Mgr04 getInstance(){if(INSTANCE == null){try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Mgr04();}return INSTANCE;}public static void main(String[] args) {for (int i = 0;i < 10;i++) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Mgr04.getInstance().hashCode());}}).start();}}
}

执行结果：

这里的synchronized关键字是加在static方法上的，所以是对这个类进行加锁，虽然保证了线程的安全性，但是在执行效率上，难免会有一定的降低

通过同步代码块的方式来提高效率

public class Mgr05 {private static Mgr05 INSTANCE;private Mgr05(){ }public static Mgr05 getInstance(){ if(INSTANCE == null){synchronized (Mgr05.class){try {Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Mgr05();}}return INSTANCE;}public static void main(String[] args) {for (int i = 0;i < 10;i++) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Mgr05.getInstance().hashCode());}}).start();}}
}

代码执行结果：

这种方式，第一个线程进入的时候，可能在执行到第一次null判断还没有进入加锁的同步代码块的时候，有其他的线程也进行判断，其他的线程先进入到同步代码块中的时候，获取到了锁，然后将下面的实例化的语句执行完了之后，释放了这个锁，然后那些执行看null值判断但是没有实例化的线程，因为对于这些线程来说，他们还是null值状态，所以会继续执行加锁的实例化代码，因此会创建出多个是对象出来。

在同步代码块中进行二次判断

public class Mgr06 {private static volatile Mgr06 INSTANCE;private Mgr06(){ }public static Mgr06 getInstance(){if(INSTANCE == null){synchronized (Mgr06.class){//双重检查INSTANCE是否为空if (INSTANCE == null) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}INSTANCE = new Mgr06();}}}return INSTANCE;}public static void main(String[] args) {for (int i = 0;i < 10;i++) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Mgr06.getInstance().hashCode());}}).start();}}
}

代码执行结果：

这里确实可以保证单例，但是整个代码结构会比较复杂

通过内部类的方式实现懒汉式加载

public class Mgr07 {private Mgr07(){}private static class Mgr07Holder{private final static Mgr07 INSTANCE = new Mgr07();}public static Mgr07 getInstance(){return Mgr07Holder.INSTANCE;}public static void main(String[] args) {{for (int i = 0;i < 100;i++) {new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Mgr06.getInstance().hashCode());}}).start();}}}
}

代码执行结果：

这里是通过内部类的方式来实现的，外部类在访问Mgr07的getInstance()方法的时候，返回的是其内部类的静态常量，这里与Mgr01一样，是JVM帮我们实现了线程的安全性，而Mgr07在加载的时候，其内部类是不会被加载的，也就是没有被实例化，只有在我们调用getInstance()方法的时候，内部类才会被加载，Mgr07才会被实例化。

大神代码（Java语音的创始人之一James Gosling在《Effective Java》中写出的代码）：

public enum Mgr08 {INSTANCE;private void m(){}public static void main(String[] args) {for (int i = 0;i < 100;i++) {new Thread(()->{System.out.println(Mgr08.INSTANCE.hashCode());}).start();}}
}

代码执行结果：

这里的是通过Java的枚举类来实现的，枚举单例，不经可以保证线程的安全性，还可以防止反序列化。Java规范中规定，每一个枚举类型极其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定：在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过 java.lang.Enum 的 valueOf() 方法来根据名字查找枚举对象。所以，以上面的枚举为例，序列号的时候只会将INSTANCE输出，然后再根据INSTANCE这个名称，查找对应的枚举类型，因此，反序列化之后得到的对象也会与序列化之后的实例对象相同。这个实在是要膜拜，不愧是Java之父。

Java设计模式之单例模式的学习相关推荐

Java设计模式之单例模式（七种写法）
Java设计模式之单例模式(七种写法) 第一种,懒汉式,lazy初始化,线程不安全,多线程中无法工作: public class Singleton {private static Singleton ...
java设计模式之单例模式(七种方法)
单例模式:个人认为这个是最简单的一种设计模式,而且也是在我们开发中最常用的一个设计模式. 单例模式的意思就是只有一个实例.单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例.这个 ...
java设计模式之——单例模式(八种实现)
一.介绍有时,我们需要某个类的实例始终只有一个,举个例子,如果用面向对象语言写的操作系统,那么桌面这个实例肯定就只有一个,无论从哪个地方进入的桌面,都是同一个. 所谓类的单例设计模式,就是采取一定的 ...
Java 设计模式(3)单例模式
前言概念: java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例.饿汉式单例.登记式单例. 单例模式有以下特点: 1.单例类只能有一个实例. 2.单例类必须自 ...
Java设计模式之单例模式(Singleton Pattern)
**单例模式:用来创造独一无二的,只能有一个实例的对象设计模式.单例模式确保一个类只有一个实例,并提供一个全局访问点.**相比于全局变量(对对象的静态引用),单例模式可以延迟实例化,而且全局变量不能保 ...
Java设计模式：单例模式
学而时习,稳固而之心, 好久没有复习java的知识了,今天有空温习了单例模式,这里记录一下单例模式是常见的设计模式的一种,其特点就是指一个类只有一个实例,且该类能自行创建这个实例 , 保证一个类 ...
Java 设计模式之单例模式
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 这种模式涉及到一个单一的类,该类负责创建自己的对 ...
Java设计模式(二) -- 单例模式
单例模式是Java中最广泛应用的设计模式之一,为创建对象提供了一种绝佳的方式.因此,在一些Java程序中, 一些管理器和控制器经常被设计为单例模式. 这种模式涉及到一个单一的类,该类负责创建自己的对象 ...
java设计模式--1.单例模式
单例模式的定义与特点单例(Singleton)模式的定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式.例如,Windows 中只能打开一个任务管理器,这样可以避免因打开多个任务管理器窗 ...

Java设计模式之单例模式的学习

Java设计模式之单例模式的学习相关推荐

最新文章

热门文章