程序员在编写代码的过程中,面临着耦合性、内聚性以及可维护性,可扩展性、重用性和灵活性等多方面的挑战,因此设计模式是为了让程序具有更好的:
①代码重用性;(相同功能不用多次编写)
②可读性;(便于其他程序员阅读和理解)
③可扩展性;(当增加新的功能时,非常方便)
④可靠性;(增加新的功能后,对原来的功能没有影响)
⑤使程序程序高内聚,低耦合;
单例模式
所谓单例模式就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)
比如获取Mybatis里的SqlSessionFactory,充当数据存储源的代理,并负责创建SqlSession对象,这种情况下,一个项目通常只需要一个SqlSessionFactory就可以了,因此就会使用到单例模式。
(1)饿汉式(静态常量)
构造器私有化;类的内部创建对象;向外暴露一个静态的公共方法。
代码:
public class Type01 {
public static void main(String[] args) {
SingleTon s1 = SingleTon.getInstance();
SingleTon s2 = SingleTon.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon {
private SingleTon() {
}
private final static SingleTon instance = new SingleTon();
public static SingleTon getInstance() {
return instance;
}
}
优缺点:
优点:写法简单,在类加载的时候就完成了实例化,避免了线程同步问题。
缺点:没有达到懒加载的效果,如果从始至终都没有使用过这个类,将会造成内存浪费。
(2)饿汉式(静态代码块)
代码:
package com.wzp.singleton;
/**
* @Author: wzp
* @Date: 2020/5/4 14:27
*/
public class Type02 {
public static void main(String[] args) {
SingleTon1 s1 = SingleTon1.getInstance();
SingleTon1 s2 = SingleTon1.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon1 {
private SingleTon1() {
}
private static SingleTon1 instance;
static {
instance = new SingleTon1();
}
public static SingleTon1 getInstance() {
return instance;
}
}
优缺点:
这种方法和上面的方法是一样的,只是将类的实例化放在了静态代码块中,类在加载时,也会执行静态代码块中的代码。优缺点和上面一样。
(3)懒汉式(线程不安全)
public class Type03 {
public static void main(String[] args) {
SingleTon2 s1 = SingleTon2.getInstance();
SingleTon2 s2 = SingleTon2.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon2 {
private SingleTon2() {
}
private static SingleTon2 instance;
public static SingleTon2 getInstance() {
if (instance == null) {
instance = new SingleTon2();
}
return instance;
}
}
优缺点:
优点:起到了懒加载的效果。
缺点:但只能在单线程下使用,如果在多线程下,一个线程进入if (instance == null)
判断语句块,还没来得及往下执行,这时另一个线程也通过了这个判断块,就会产生多个实例。在实际开发中,不能用这种方式。
(4)懒汉式(线程安全)
这种方法只是在上面创建实例对象的方法加了synchronized
代码:
public class Type04 {
public static void main(String[] args) {
SingleTon3 s1 = SingleTon3.getInstance();
SingleTon3 s2 = SingleTon3.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon3 {
private SingleTon3() {
}
private static SingleTon3 instance;
public static synchronized SingleTon3 getInstance() {
if (instance == null) {
instance = new SingleTon3();
}
return instance;
}
}
优缺点:
优点:解决了线程不安全的问题
缺点:但效率太低了,每个线程要想获得实例对象时都要通过synchronized,而其实这个方法只执行一次实例化代码就够了,后面的想获得实例,直接return就行。在实际开发中,也不推荐这种方式。
(5)懒汉式(线程不安全和同步代码块)
代码:
public class Type05 {
public static void main(String[] args) {
SingleTon4 s1 = SingleTon4.getInstance();
SingleTon4 s2 = SingleTon4.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon4 {
private SingleTon4() {
}
private static SingleTon4 instance;
public static SingleTon4 getInstance() {
if (instance == null) {
synchronized (SingleTon4.class) {
instance = new SingleTon4();
}
}
return instance;
}
}
优缺点:
虽然较上面的方法效率高了,但这种同步并不能起到线程安全的作用。
(6)双重校验锁
代码:
public class Type07 {
public static void main(String[] args) {
SingleTon6 s1 = SingleTon6.getInstance();
SingleTon6 s2 = SingleTon6.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon6 {
private SingleTon6() {
}
//volatile的作用是立即更新到主存
private static volatile SingleTon6 instance;
public static SingleTon6 getInstance() {
if (instance == null) {
synchronized (SingleTon5.class) {
if (instance == null) {
instance = new SingleTon6();
}
}
}
return instance;
}
}
优缺点:
①进行了两次if (instance == null)
的检查,保证了线程安全;
②实例化代码只执行一次,后面再次访问时,判断if (instance == null)
,直接return实例化对象,避免反复进行方法同步。
③延迟加载,效率高。在开发中,经常用这种单例设计模式。
(7)静态内部类
代码:
public class Type08 {
public static void main(String[] args) {
SingleTon7 s1 = SingleTon7.getInstance();
SingleTon7 s2 = SingleTon7.getInstance();
System.out.println(s1 == s2);
}
}
class SingleTon7 {
private SingleTon7() {}
private static class SingletonInstance {
private static final SingleTon7 INSTANCE = new SingleTon7();
}
public static SingleTon7 getInstance() {
return SingletonInstance.INSTANCE;
}
}
优缺点:
①这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
②静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化。
③类的静态属性只会在第一次加载类的时候才会初始化,在这里JVM帮我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
④实现了延迟加载,避免了线程不安全,推荐使用。
(8)枚举
public class Type09 {
public static void main(String[] args) {
Singleton8 s1 = Singleton8.INSTANCE;
Singleton8 s2 = Singleton8.INSTANCE;
System.out.println(s1 == s2);
}
}
enum Singleton8 {
INSTANCE; //只有一个属性,保证它是单例的
}
优缺点:
不仅能避免多线程问题,而且能防止反序列化重新创建新的对象,推荐使用。
(9)jdk中使用到单例模式的例子
java.lang.Runtime是经典的单例模式,采用饿汉式(静态常量)。