后台-插件-广告管理-内容页广告位一(手机)

您现在的位置是:首页 > 编程语言 > 其他编程其他编程

浅谈设计模式及Singleton

2021-04-18 18:44:44其他编程人已围观

简介




目录
前言设计模式(design pattern)?设计模式分类:一、创建型模式

目录

  • 前言
  • 设计模式(design pattern)?
    • 设计模式分类:
      • 一、创建型模式
      • 二 、结构型模式
      • 三、行为型模式
  • Singleton Pattern(单例模式)?
    • 饿汉式
    • 懒汉式
    • 双重判断
    • 静态内部类
    • 枚举式

前言

在我们平时的工作学习中,代码的整洁与高可用会让程序更加有效率,对项目的好处不言而喻。

设计模式的学习会让我们的编程水平得到很大的提升,同时也有助于对框架的理解,因为优秀的框架结构都用到了设计模式。

今天先瞅瞅单例模式,剩余的设计模式我也会慢慢更新,做一个系列。


设计模式(design pattern)?

设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 是对面向对象设计中反复出现的问题的解决方案

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

Java设计模式贯彻的原理是:面向接口编程,而不是面向实现。其目标的原则是:降低耦合,增强灵活性。

设计模式分类:

一、创建型模式

创建型模式是用来创建对象的模式,抽象了实例化的过程,帮助一个系统独立于其关联对象的创建、组合和表示方式。

所有的创建型模式都有两个主要功能:

  1. 将系统所使用的具体类信息封装起来;
  2. 隐藏类的实例是如何被创建和组织的。外界对于这些对象只知道他们共同的接口,而不清楚其具体的实现细节。

常见的创建型模式:

  • 单例模式(Singleton Pattern)
  • 工厂方法模式(Factory Pattern)
  • 抽象工厂模式(Abstract Factory Pattern)
  • 建造者模式(Builder Pattern)
  • 原型模式(Prototype pattern)

二 、结构型模式

结构型模式讨论的是类和对象的结构,它采用继承机制来组合接口或实现(类结构型模式),或者通过组合一些对象实现新的功能(对象结构型模式)。

常见结构型模式:

  • 代理模式(Proxy)
  • 装饰模式(Decorator)
  • 适配器模式(Adapter)
  • 组合模式(Composite)
  • 桥梁模式(Bridge)
  • 外观模式(Facade)
  • 享元模式(Flyweight)

三、行为型模式

行为型模式关注的是对象的行为,用来解决对象之间的联系问题。

常见行为型模式:

  • 模板方法模式(Template Method)
  • 命令模式(Commend)
  • 责任链模式(Chain of Responsibility)
  • 策略模式(Strategy)
  • 迭代器模式(Iterator)
  • 中介者模式(Mediator)
  • 观察者模式(Observer)
  • 备忘录模式(Memento)
  • 访问者模式(Visitor)
  • 状态模式(State)
  • 解释器模式(Interpreter)

Singleton Pattern(单例模式)?

定义:Ensure a class has only one instance, and provide a global Point of access to it.
确保一个类只有一个实例存在。

最好学习方法就是分析代码:

饿汉式

/**
 * 饿汉式(类加载时,就进行对象实例化)
 * 类加载到内存后,就实例化一个单例,JVM保证线程安全
 * 类只加载一次,实例化一次   Class.forName()
 * 缺点:类完成加载,就完成实例化
 */
public class Manager01 {
	//private确保构造方法无法被外界实例化
    private Manager01(){
    }
    //静态常量(或变量)
    private static final Manager01 INSTANCE = new Manager01();
	//通过该方法获得实例
    public static Manager01 getInstance(){
        return INSTANCE;
    }
	//其余业务方法
    public void useOthers(){
    }

    public static void main(String[] args) {
    	
        Manager01 instance1 = Manager01.getInstance();
        Manager01 instance2 = Manager01.getInstance();
		//输出结果为True,同一个对象
        System.out.println(instance1==instance2);
    }
}

懒汉式

/**
 * 懒汉式(第一次引用类时,才进行对象实例化)
 * Lazy Loading
 * 按需初始化,但要保证多线程并发安全
 */
public class Manager02 {
    private Manager02(){}
    private static Manager02 INSTANCE;

    public static Manager02 getInstance(){
    //public static synchronized Manager02 getInstance()
    //加锁亦可在方法上,保证同步,多线程容易发生创建多个实例
        synchronized (Manager02.class){
        	//判断是否已实例化
            if (INSTANCE==null){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Manager02();
            }
            return INSTANCE;
        }
    }
	//业务方法等
    public void useOthers(){}

    public static void main(String[] args) {
    	//创建100个线程,结果只有一个实例被创建
        for (int i = 0; i < 100; i++) {
            //lambda表达式
            new Thread(()->{
                System.out.println(Manager02.getInstance().hashCode());
            }).start();
        }
    }
}

双重判断

懒汉式模式会加锁,导致效率降低,双重模式是对懒汉的优化

/**
 * 双重判断
 */
public class Manager03 {
    private Manager03(){}
    private static Manager03 instance;

    public static Manager03 getInstance(){
        
        //判断第一次,若实例已存在,直接跳转返回instance。无需等待锁的释放
       if (instance==null){
           synchronized (Manager03.class){
           	    //二次判断,若此时已存在实例,就跳过if块
               if (instance==null){
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   
                   instance = new Manager03();
                   return instance;
               }
           }
       }
       return instance;
    }

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

静态内部类

/**
 * 静态内部类
 * 加载外部类时不会加载内部类,懒加载
 */
public class Manager04 {
    private Manager04(){}

    private static class managerHolder { 
        private final static Manager04 INSTANCE = new Manager04();
    }

    public static Manager04 getInstance(){
        return managerHolder.INSTANCE;
    }

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

枚举式

/**
 * 枚举单例
 * 大佬写的,不仅解决线程同步,还可以反序列化
 * 完美
 */
public enum Manager05 {

    INSTANCE;

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

最常用最简单的就是饿汉式,懒汉式了。

上面示例为看视频总结手敲,很精妙

文章来源:查看

Tags:设计模式   java   多线程  

很赞哦! ()

后台-插件-广告管理-内容页广告位二(手机)
后台-插件-广告管理-内容页广告位三(手机)

随机图文

后台-插件-广告管理-内容页广告位四(手机)

文章评论

留言与评论(共有 0 条评论)
   
验证码:

本栏推荐

站点信息

  • 文章统计13614篇文章
  • 浏览统计468次浏览
  • 评论统计1个评论
  • 标签管理标签云
  • 统计数据:统计代码
  • 微信公众号:扫描二维码,关注我们