设计模式-第3篇-单例模式

于 2019-08-02 10:39:07 发布
阅读量247 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MuZiYu2015/article/details/98179160
版权

1.单例设计模式的八种方法

  • 饿汉式（静态常量）
  • 饿汉式（静态代码块）
  • 懒汉式（线程不安全）
  • 懒汉式（线程安全，同步方法）
  • 懒汉式（线程安全，同步代码块）
  • 双重检查
  • 静态内部类
  • 枚举

2.饿汉式（静态常量）

public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton1 instance1 = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        System.out.println(instance1 == instance2); //true
    }
}

/**
 * 饿汉式（静态变量的方式）
 */
class Singleton1 {
    //私有静态变量，上来就创建对象
    private final static Singleton1 instance = new Singleton1();

    //私有构造方法
    private Singleton1() {

    }

    //提供公有的供外部访问的方法
    public static Singleton1 getInstance() {
        return instance;
    }
}

优点：

  • 写法简单，类装载的时候就完成实例化，基于classloader机制避免线程同步问题

缺点：

  • 在类装载时就实例化，没有达到lazy loading的效果。如果从始至终未用到这个类，就会造成内存的浪费

总结：

这种单例模式可用，但可能造成内存浪费

3.饿汉式（静态代码块）

public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton2 instance1 = Singleton2.getInstance();
        Singleton2 instance2 = Singleton2.getInstance();
        System.out.println(instance1 == instance2); //true
    }
}

/**
 * 饿汉式（静态代码块的方式）
 */
class Singleton2 {
    //私有静态变量，仅做定义
    private static Singleton2 instance;

    //静态代码块中实例化
    static {
        instance = new Singleton2();
    }

    //私有构造方法
    private Singleton2() {

    }

    //提供公有的供外部访问的方法
    public static Singleton2 getInstance() {
        return instance;
    }
}

4.懒汉式（线程不安全-单线程可用）

public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

/**
 * 懒汉式
 */
class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        //为空时才创建对象，起到懒加载的效果
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

优点：

起来懒加载的效果

缺点：

只能在单线程下使用。

原因如下：

如果在多线程下，一个线程进入了if (instance == null)判断语句块，还未来得及向下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例，所以在多线程下不可使用此种方式

验证demo

public class SingletonTest {
    public static void main(String[] args) {
//        Singleton instance1 = Singleton.getInstance();
//        Singleton instance2 = Singleton.getInstance();
//        System.out.println(instance1 == instance2);

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":hashcode-"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

/**
 * 懒汉式
 */
class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() throws InterruptedException {
        //为空时才创建对象，起到懒加载的效果
        if (instance == null) {
            Thread.sleep(1000);
            instance = new Singleton();
        }
        return instance;
    }

}

在这里插入图片描述

总结：

不要采用，会出现线程安全问题

5.懒汉式（线程安全，同步方法）

实现方式仅仅是在public static Singleton getInstance()上增加一个synchronized关键字

public class SingletonTest {
    public static void main(String[] args) throws InterruptedException {
//        Singleton instance1 = Singleton.getInstance();
//        Singleton instance2 = Singleton.getInstance();
//        System.out.println(instance1 == instance2);

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

/**
 * 懒汉式-获取对象实例的方法加锁
 */
class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() throws InterruptedException {
        //为空时才创建对象，起到懒加载的效果
        if (instance == null) {
            Thread.sleep(1000);
            instance = new Singleton();
        }
        return instance;
    }

}
  • 解决了线程不安全的问题
  • 效率太低了。每个线程在获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低。
  • 实际开发不推荐

6.懒汉式（线程不安全，同步代码块）

public class SingletonTest {
    public static void main(String[] args) throws InterruptedException {
//        Singleton instance1 = Singleton.getInstance();
//        Singleton instance2 = Singleton.getInstance();
//        System.out.println(instance1 == instance2);

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() ->{
            try {
                Singleton instance3 = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName()+":"+instance3.hashCode());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

/**
 * 懒汉式
 */
class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() throws InterruptedException {
        //为空时才创建对象，起到懒加载的效果
        if (instance == null) {
            synchronized (Singleton.class){
                Thread.sleep(1000);
                instance = new Singleton();
            }
        }
        return instance;
    }

}

并不能解决线程安全问题

在这里插入图片描述

7.双重检查（线程安全并推荐）

/**
 * 懒汉式-双重检查优化同步代码块线程不安全的问题
 */
class Singleton {

    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() throws InterruptedException {
        //为空时才创建对象，起到懒加载的效果
        if (instance == null) {
            //为null时才加锁，保证只有一条线程创建对象
            synchronized (Singleton.class) {
                if (instance == null) {
                    Thread.sleep(1000);
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

两次进行if 检查，保证线程安全。这样实例化代码只用执行一次，并且保证只能由一个线程执行，后面再次访问是，再次判断if是否为nul。直接return实例化对象，避免了反复进行方法同步。

  • 线程安全，延迟加载，效率较高
  • 实际开发推荐

8.静态内部类（推荐）

特点是，外部类装载时内部类不会被装载，只有在调用内部类的相关方法和属性时，才会被装载，并且只被装载一次

/**
 * 静态内部类
 */
class Singleton {

    // 定义私有的静态内部类
    private static class SingletonInnerInstance {
        private static final Singleton SINGLETON_INSTANCE = new Singleton();
    }

    private Singleton() {
    }

    // 返回静态内部生成的外部类对象
    public static Singleton getInstance() {
        return SingletonInnerInstance.SINGLETON_INSTANCE;
    }

}

  • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程

    在这里插入图片描述

9.枚举（推荐）

public class SingletonTest {
    public static void main(String[] args) {
        SingletonEnum instance1 = SingletonEnum.INSTANCE;
        SingletonEnum instance2 = SingletonEnum.INSTANCE;
        System.out.println(instance1 == instance2);
    }
}

/**
 * 利用枚举实现单例
 */
enum SingletonEnum {
    INSTANCE;

    public void method1() {
        System.out.println("OK...");
    }
}
  • 避免多线程同步问题
  • 防止反序列化重新创建新的对象
  • Effective Java提倡。推荐使用

10.JDK源码分析

在这里插入图片描述

11.单例模式-总结

  • 单例节省了系统资源，对于一些需要频繁创建和销毁的对象，使用单例模式可以提高系统性能
  • 当想实例化一个单例类的时候，必须要记住使用响应的获取对象的方法，而不是直接new
  • 使用场景：
    • 需要频繁创建和销毁的对象
    • 创建对象时耗时过多或耗费资源过多（重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session工厂等）

12.个人应用实战

将工具类修改为单例模式-------

使用双重检查、静态内部类都可以

要改为单例的工具类最好是那种类似数据库连接池工具类那种，涉及到配置、可扩展那种。否则不如使用静态方法的方式

慕紫羽
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值