代码实验02:设计模式-单例模式

单例模式-JAVA实验 这种设计模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。在这些场景中,需要确保只有一个实例对象被创建,否则可能会出现资源的浪费和对象的重复创建等问题。通过实验,熟练使用Java语言实现单例设计模式,理解这种种设计模式的模式动机,掌握模式结构,学习如何使用代码实现这些模式,并学会分析这些模式的使用效果。首先,定义一个 ShoppingCartManager 类,作为购物车管理器,使用单例模式来确保在整个应用程序中只有一个实例对象被创建。单例模式在实际开发中的应用极其广泛。 阅读详情

目录

单例模式的定义

单例模式的分类

单例模式的Java实现

多线程环境下的懒汉式单例

单例模式的应用

Spring的单例模式底层实现


本文脑图​

前面讲了设计模式的介绍,传送门:设计模式概述

单例模式是创建型设计模式的一种,也是最简单的一种设计模式。

单例模式的定义

Ensure a class has only one instance,and provide a global point of access toit.

上面是单例模式的英文阐述,意思是确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。单例模式的主要作用是确保一个类只有一个实例存在。

单例模式的分类

在Java语言的环境下,单例模式可以分为两种。

  • 懒汉式单例

  • 饿汉式单例

饿汉式单例是指类一加载就实例化对象,就好比一个老汉吃胡萝卜都懒得煮熟,直接就生吃,懒汉式单例因此得名。

相反,懒汉式单例是指类在加载时不实例化对象,只有等到第一次用的时候才去实例化。

饿汉式单例主要是考虑避免造成资源浪费,因为不确定这个单例对象是否会被用到,所以等到要用了我才去创建,这样就避免了资源浪费,要知道创建对象是非常耗费资源的,特别是大对象。这就好比线上商店卖货,有订单了,我才生产商品。

单例模式的Java实现

网上有些人朋友认为设计模式只有在写Java时才有用,实际上这种观点有失偏颇,设计模式强调的是复用性理念,把很多问题的共性特征抽取出来形成一套可复用的解决方案就变成了设计模式。当然目前狭义的软件设计模式指的还是GoF中提出的23种模式。

饿汉式单例的代码实现:

    public class Singleton {
        // 实例化单例对象
        private static Singleton singleton = new Singleton();
        // 私有化构造方法,防止被外部创建对象
        private Singleton() {}
        // 对外提供方法获取该对象
        public static Singleton getSingleton() {
            return singleton;
        }
    }    

懒汉式单例的代码实现:

    public class Singleton {
        // 先定义单例对象为null,不实例化
        private static Singleton singleton = null;
        // 私有化构造方法,防止被外部创建对象
        private Singleton() {}
        // 对外提供方法获取该对象
        public static Singleton getSingleton() {
            // 当调用该方法时先判断对象是否为null,如果为null才实例化
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }

稍微学过多线程的同学就会发现饿汉式单例在多线程环境下有问题,可能会创建出多个对象来,就违背了单例模式的定义了,我们来实验一下:

public class MainTest {
    public static void main(String[] args) {
// 创建50个线程获取单例对象,我们来看多次运行后单例对象的内存地址是否一样,

如果出现不一样则说明创建了多个对象。

for (int i = 0; i < 50; i++) {
new Thread(new Runnable() {
@Override
public void run() {
Singleton singleton = Singleton.getSingleton();
// 打印该单例对象的内存引用地址
System.out.println(singleton);
}
}).start();
}
}
}

多次运行后结果如下:

可以看到明细出来了三个不同的对象了。

那么多线程环境下的单例模式如何确保对象的唯一性呢?

多线程环境下的懒汉式单例

懒汉式单例为什么会存在线程安全问题?

这是因为多个线程去调用getInstance方法来获取Singleton的实例,那么就有可能发生这样一种情况,当第一个线程在执行if(singleton == null)时,此时singleton是为null的进入语句。在还没有执行singleton = new Singleton()时(此时instance是为null的),巧了,这时候第二个线程也进入了if(singleton == null)这个语句,因为之前进入这个语句的线程中还没有执行singleton = new Singleton(),所以它也会执行singleton = new Singleton()来实例化Singleton对象,因为第二个线程也进入了if语句所以它会实例化Singleton对象。

这样就导致了实例化了两个Singleton对象。

如何解决呢?

分三步:

  1. 加同步锁

  2. 双重检查判断,也就我们说的double check

  3. 使用volatile关键字禁止指令重排序

最完整的懒汉式单例模式

public class Singleton {
    // 先定义单例对象为null,不实例化
    // 第二层锁,volatile关键字禁止指令重排
    private static volatile Singleton singleton = null;
​
    // 私有化构造方法,防止被外部创建对象
    private Singleton() {}
​
    // 对外提供方法获取该对象
    public static Singleton getSingleton() {
        // 当调用该方法时先判断对象是否为null,如果为null才实例化
        // 第一层检查,检查是否有引用指向对象,高并发情况下会有多个线程同时进入
        if (singleton == null) {
            // 第一层锁,保证只有一个线程进入
            synchronized (Singleton.class) {
                // 第二层检查
                if(singleton==null) {
                    //volatile关键字作用为禁止指令重排,保证返回Singleton对象一定在创建对象后
                    singleton = new Singleton();
                    //singleton = new Singleton语句为非原子性,实际上会执行以下内容:
                    //(1)在堆上开辟空间;(2)属性初始化;(3)引用指向对象
                    //假设以上三个内容为三条单独指令,因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),当单例模式中存在普通变量需要在构造方法中进行初始化操作时,单线程情况下,顺序重排没有影响;但在多线程情况下,假如线程1执行singleton=new Singleton()语句时先1再3,由于系统调度线程2的原因没来得及执行步骤2,但此时已有引用指向对象也就是singleton!=null,故线程2在第一次检查时不满足条件直接返回singleton,此时singleton为null(即str值为null)
                    //volatile关键字可保证singleton=new Singleton()语句执行顺序为123,因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断),但能确保的是只要singleton!=0,就表明一定执行了属性初始化操作;而若在步骤3之前被打断,此时singleton依旧为null,其他线程可进入第一层检查向下执行创建对象
                }
            }
        }
        return singleton;
    }
}

单例模式的应用

1. 单例模式的优点

■ 由于单例模式在内存中只有一个实例,减少了内存的开支,特别是一个对象需要频繁地创建、销毁,而且创建或销毁的性能又无法优化时,单例模式的优势就非常明显。

■ 由于单例模式只生成一个实例,所以减少了系统的性能开销,当一个对象的产生需要比较多资源时,如读取配置、产生其他依赖对象时,则可以通过在启用时直接产生一个单例对象,然后用永久驻留内存的方式来解决。

■ 单例模式可以避免对资源的多重占用,例如,一个写文件动作,由于只有一个实例存在于内存中,避免了对同一个资源文件的同时操作。

■ 单例模式可以在系统设置全局的访问点,优化和共享资源访问,例如,可以设计一个单例类,负责所有数据表的映射处理。

2. 单例模式的缺点

■ 单例模式无法创建子类,扩展困难,若要扩展,除了修改代码基本上没有第二种途径可以实现。

■ 单例模式对测试不利。在并行开发环境中,如果采用单例模式的类没有完成,是不能进行测试的;单例模式的类通常不会实现接口,这也妨碍了使用mock的方式虚拟一个对象。

■ 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑,而不关心它是否是单例的,是不是要用单例模式取决于环境,单例模式把“要单例”和业务逻辑融合在一起。

3. 单例模式的使用场景

■ 生成唯一序列号

■ 需要一个共享访问点或共享数据:如web页面的计数器

■ Spring框架中,每个Bean 默认就是单例的

■ Java 基础类库中的 java.lang.Runtime 类也采用了单例模式

Spring的单例模式底层实现

前面也提到了单例模式的缺点,单例模式无法创建子类,也就是不能被继承,所以就无法扩展。

为了克服单例模式不能被继承的缺点,我们可以使用另外一种特殊化的单例模式,它被称为单例注册表。

import java.util.HashMap;
 public class RegSingleton {
    static private HashMap<String, Object> registry = new HashMap();
    //静态块,在类被加载时自动执行
    static {
        RegSingleton rs = new RegSingleton();
        registry.put(rs.getClass().getName(), rs);
    }
    //受保护的默认构造函数,如果为继承关系,则可以调用,克服了单例类不能为继承的缺点  
    protected RegSingleton() {
    }
    //静态工厂方法,返回此类的唯一实例  
    public static RegSingleton getInstance(String name) {
        if (name == null) {
            name = "RegSingleton";
        }
        // 这里仅作为演示,不考虑线程安全问题
        if (registry.get(name) == null) {
            try {
                registry.put(name, Class.forName(name).newInstance());
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return (RegSingleton) registry.get(name);
    }
 }

那么Spring对单例的底层实现,到底是饿汉式单例还是懒汉式单例呢?

都不是。Spring框架对单例的支持是采用单例注册表的方式进行实现的,源码如下:

public abstract class AbstractBeanFactory implements ConfigurableBeanFactory{  
       /** 
        * 充当了Bean实例的缓存,实现方式和单例注册表相同 
        */  
       private final Map singletonCache=new HashMap();  
       public Object getBean(String name)throws BeansException{  
           return getBean(name,null,null);  
       }  
    ...  
       public Object getBean(String name,Class requiredType,Object[] args)throws BeansException{  
          //对传入的Bean name稍做处理,防止传入的Bean name名有非法字符(或则做转码)  
          String beanName=transformedBeanName(name);  
          Object bean=null;  
          //手工检测单例注册表  
          Object sharedInstance=null;  
          //使用了代码锁定同步块,原理和同步方法相似,但是这种写法效率更高  
          synchronized(this.singletonCache){  
             sharedInstance=this.singletonCache.get(beanName);  
           }  
          if(sharedInstance!=null){  
             ...  
             //返回合适的缓存Bean实例  
             bean=getObjectForSharedInstance(name,sharedInstance);  
          }else{  
            ...  
            //取得Bean的定义  
            RootBeanDefinition mergedBeanDefinition=getMergedBeanDefinition(beanName,false);  
             ...  
            //根据Bean定义判断,此判断依据通常来自于组件配置文件的单例属性开关  
            //<bean id="date" class="java.util.Date" scope="singleton"/>  
            //如果是单例,做如下处理  
            if(mergedBeanDefinition.isSingleton()){  
               synchronized(this.singletonCache){  
                //再次检测单例注册表  
                 sharedInstance=this.singletonCache.get(beanName);  
                 if(sharedInstance==null){  
                    ...  
                   try {  
                      //真正创建Bean实例  
                      sharedInstance=createBean(beanName,mergedBeanDefinition,args);  
                      //向单例注册表注册Bean实例  
                       addSingleton(beanName,sharedInstance);  
                   }catch (Exception ex) {  
                      ...  
                   }finally{  
                      ...  
                  }  
                 }  
               }  
              bean=getObjectForSharedInstance(name,sharedInstance);  
            }  
           //如果是非单例,即prototpye,每次都要新创建一个Bean实例  
           //<bean id="date" class="java.util.Date" scope="prototype"/>  
           else{  
              bean=createBean(beanName,mergedBeanDefinition,args);  
           }  
    }  
    ...  
       return bean;  
    }  
 }

我是Seven,一个不懈努力的程序猿,希望本文能对你有所裨益

Web页面是如何呈现的?

如何看懂Apache Log4j 远程代码执行漏洞原理?

细数Java8-14的那些经典特性,语言的车轮正在滚滚向前...

要使用消息队列,以下这些你都要知道...

GC如何判断一个对象是否为垃圾?深度剖析三色标记算法原理

设计模式概述

实验五:单例模式.rar 实验五:单例模式.rar实验五:单例模式.rarjava设计模式 立即下载

相关推荐

腾讯游戏安全组件运行异常的全面解决方案

在使用腾讯游戏时,玩家可能会遭遇游戏安全组件运行异常的问题,这不仅影响游戏的正常启动,还可能在游戏过程中引发一系列问题。本文将详细介绍解决腾讯游戏安全组件运行异常的几种方法,帮助玩家重拾游戏乐趣。腾讯游戏安全组件运行异常是一个复杂的问题,可能涉及服务设置、游戏更新、系统环境优化以及硬件与驱动检查等多个方面。最后,希望本文能帮助玩家顺利解决腾讯游戏安全组件运行异常的问题,让玩家能够无忧无虑地享受游戏带来的乐趣。首先,我们需要从系统的服务管理入手,检查与游戏安全组件相关的服务是否正常运行。

nntxthml的博客 5820

设计模式-单例模式实践案例

单例模式(Singleton Pattern)是一种常用的设计模式,它确保一个类只有一个实例,并提供一个全局访问点。

guanglihuan的专栏 472

Unity AssetBundle 之 (入门)简单的资源打包成AB包的方法

Unity AssetBundle 之 (入门)简单的资源打包成AB包的方法 目录 Unity AssetBundle 之 (入门)简单的资源打包成AB包的方法 一、简单介绍 二、实现原理 三、注意事项 四、效果预览 五、实现步骤 六、关键代码 一、简单介绍 Unity中的一些基础知识点。 本节介绍,Asset Bundle 在 Unity中的使用,入门第一篇,如何AssetBundle标记,如何打包成AssetBundle的操作方法,有不对的地方欢迎指正。...

仙魁XAN 1万+

网络编程(13)——单例模式

单例模式(Singleton),保证一个类仅有一个实例,并提供一个访问它的全局访问点,单例模式是在内存中仅会创建一次对象的设计模式。//通过静态成员变量实现单例//懒汉式private:public:在上面的代码块中,定义了一个Single2类,Single2类的默认构造函数被声明为私有,且删除拷贝构造函数和赋值运算符,确保Single2类不能通过拷贝创建或赋值创建新的实例。Single2类只有一个公共静态方法GetInst(),用于获取Single2类的唯一实例。

m0_63086198的博客 1201

是德频谱分析仪相位噪声测量实战指南:从原理到精准操作

本文详细介绍了是德频谱分析仪在相位噪声测量中的实战操作指南,从基础概念到高级技巧全面解析。通过5G基站时钟测量等实际案例,展示如何利用是德N9030B等设备精准测量相位噪声,并分享设备预热、参数设置、环境干扰排除等关键操作要点,帮助工程师提升测量精度和效率。

jenkins8butler的博客 230

信贷风控分析—征信数据源

详解企业和个人征信报告,以及信贷风控之指标构造案例参考

csdnbt的博客 3646

单例模式 实践与尝试

单例模式中的代码实践饿汉式,懒汉式,懒汉的线程安全.

银刺猬的博客 318

FreeSwitch采用mrcp协议对接科大讯飞asr和tts以及对话系统

FreeSwitch采用mrcp协议对接科大讯飞asr和tts对接过程

shanghaimoon的专栏 8843

java设计模式实验一_单例模式

饿汉模式// 饿汉模式public class Wife {// 一开始就新建一个实例private static final Wife wife = new Wife();// 默认构造方法private Wife() {}// 获得实例的方法public static Wife getWife() {return wife;}}懒汉模式// 懒汉模式public class Wife {//一...

weixin_30747255的博客 232

【OpenClaw企业级智能体实战】第16篇:电商“龙虾”掘金记:用OpenClaw实现小红书/抖音/淘宝全自动矩阵运营(2026实测版)

2026年,OpenClaw(小龙虾)已成为电商运营的核心效率工具——从公众号文案3分钟生成到TikTok爆款视频1小时复刻,从多平台内容同步到自动比价加购,彻底重构了电商运营的工作模式。本文基于真实商业案例(元岳科技、TikTok跨境卖家、淘宝MCP工具),系统拆解电商智能体的落地路径:先详解OpenClaw在电商场景的核心原理与变现模式(代部署、模板售卖、轻定制、内容套利),再提供阿里云/本地双部署方案,完整实现小红书/抖音/淘宝的自动化运营(热点抓取、内容生成、多平台分发、数据分析)。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 2302

国科大学习资料--数据挖掘(刘莹)--第三章习题及参考答案

国科大学习资料–数据挖掘(刘莹)–第三章习题及参考答案 国科大学习资料–数据挖掘(刘莹)–第三章习题及参考答案 国科大学习资料–数据挖掘(刘莹)–第三章习题及参考答案 第 3 章分类与回归 3.1简述决策树分类的主要步骤。 答:决策树生成的过程如下: (1)对数据源进行数据预处理, 得到训练集和测试集; (2)对训练集进行训练; (3)对初始决策树进行树剪枝; (4)由所得到的决策树提取分类规则; (5)使用测试数据集进行预测,评估决策树模型; 3.2给定决策树,选项有:(1)将决策树转换成规则,然后对结果

无名何许人的博客 3094

设计模式实战教程:基于 youngyangyang04/DesignPattern 开源项目

设计模式实战教程:基于 youngyangyang04/DesignPattern 开源项目 本教程旨在全面介绍位于 GitHub 的设计模式开源项目。通过深入浅出的讲解,我们将涵盖项目的核心要素,提供快速上手指南,展示经典应用场景,以及探索其在技术生态中的位置。 1. 项目介绍 设计模式 是软件开发中的一套成熟解决方案,用于解决常见的设计问题并促进代码的可重用性、可维护性和扩展性。此开源项目 D...

gitblog_00568的博客 1058

C#【通用方法】字节数组添加、移除、获取的方法类(妙用List<byte>,开发中常用)

C#【通用方法】添加移除字节的方法类(妙用List,开发中常用)

星Yeah 的博客 3361

设计模式实践教程 - 基于 micooz/DesignPattern 开源项目

设计模式实践教程 - 基于 micooz/DesignPattern 开源项目 项目介绍 该项目由 Github 用户 micooz 维护,是针对软件开发中常见设计模式的实现集合。它旨在提供一个学习和理解各种设计模式的实战平台,涵盖了从单例模式到观察者模式等二十多种经典设计模式。通过此仓库,开发者可以深入学习每种模式的概念、应用场景及其实现细节,助力提升代码质量和可维护性。 项目快速启动 环境要求...

gitblog_00751的博客 819

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

设计模式-单例模式

设计模式记录学习单例模式是java中最简单的设计模式之一,这种类型的设计模式属于创建类型的一种,它提供了创建对象的最佳方式。就是采取一定的方法保证在整个软件系统中,对某个类只能存在一个对象实例,并且该类只提供了一个取得其对象实例的静态方法。例如Hibernate的sessionFactory 它充当数据存储源代理,并且负责创建Session对象.SessionFactory并不是轻量级,一般情况下,一个项目只需要一个SessionFactory,这时就会用到单例模式单例模式注意事项和细节说明。

qq_41217095的博客 1654

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

02. 设计模式之单例模式

单例模式 文章目录单例模式设计模式概述设计模式介绍设计模式类型单例设计模式单例设计模式介绍单例模式八种方式1. 饿汉式(静态常量)步骤如下:优缺点说明:2. 饿汉式(静态代码块)代码演示优缺点说明3. 赖汉式(线程不安全)代码演示优缺点说明4. 懒汉式(线程安全,同步方法)代码演示优缺点说明5. 懒汉式(线程安全,同步代码块)代码演示优缺点说明6. 双重检查(DCL)代码演示优缺点说明7. 静态内部类代码演示优缺点说明8. 枚举代码演示优缺点说明单例模式注意事项和细节说明 设计模式概述 设计模式介绍 设

JustToFaith 3473

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

C++面试宝典设计模式之单例模式

软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。设计模式是面试热门考点,掌握设计模式可以让你深入理解面向对象思想,使设计方案更加灵活,方便后期维护修改。单例模式属于创建型模式,这种模式涉及到一种单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式。单例类的特征: 1.单例类最多只能有一个实例。

wyhplus的博客 1133

设计模式之单例模式

设计模式之单例模式

weixin_61492871的博客 1352

【设计模式:单例模式】单例模式01:饿汉模式

单例模式:饿汉模式 正文开始@Assassin 目录:单例模式:饿汉模式1. 什么是设计模式?2. 单例设计模式:2.1 什么是单例模式?2.2 单例模式应用实例: 1. 什么是设计模式? 设计模式是静态方法和属性的经典应用 设计模式是在大量的实践中总结和理论化之后的优选的代码结构,编程风格以及解决问题的思考方式。设计模式可以想象成经典的棋谱,面对不同的棋局,我们便用不同的棋谱,省去了我们自己再去思考和摸索的过程 简而言之,就是面对一些相同的类似的场景我们可以用一些总结出来的惯用套路去解决问题,这大大

NingHai's blog 1610

Java 设计模式 - 单例模式

Java 设计模式 - 单例模式 作者: 霍英俊 [huo920@live.com] 文章目录Java 设计模式 - 单例模式单例设计模式介绍单例设计模式八种方式饿汉式 - 静态常量饿汉式(静态常量)应用实例优缺点说明饿汉式 - 静态代码块饿汉式(静态代码块)应用实例优缺点说明懒汉式 - 线程不安全懒汉式线程不安全应用实例优缺点说明懒汉式 - 线程安全,同步方法懒汉式线程安全,同步方法应用实例优缺点说明懒汉式 - 线程安全,同步代码块懒汉式 线程安全,同步代码块应用实例优缺点说明懒汉式 - 双重检查 - 推

霍英俊 1737

DesignPattern 开源项目教程

DesignPattern 开源项目教程 1. 项目的目录结构及介绍 DesignPattern 项目的目录结构如下: DesignPattern/ ├── src/ │ ├── AbstractFactory/ │ ├── Adapter/ │ ├── Bridge/ │ ├── Builder/ │ ├── ChainOfResponsibility/ │ ├── Co...

gitblog_00406的博客 559

常见的设计模式【单例模式&工厂模式】

常见开发模式中单例模式、工厂模式的相关介绍

yifei_345678的博客 1047

设计模式02:单例模式

设计模式02:单例模式饿汉式饿汉式单例模式的写法饿汉式单例模式的优劣分析懒汉式懒汉式单例模式的写法懒汉式单例模式的优劣分析一种错误的懒汉式写法双重检查式双重检查式单例模式的写法双重检查式单例模式的优点(没有缺点)静态内部类式静态内部类式单例模式的写法静态内部类式单例模式的优劣分析枚举式枚举式单例模式的写法枚举类单例模式的优劣分析 所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某...

ncepu_Chen的博客 420

代码操作中经常使用到设计模式之单例模式

前言:应一位朋友之邀继续分享一下设计模式,关于设计模式的基本介绍在上一篇文章已经有所描述,这篇就不多做赘述。今天给大家介绍一下设计模式的里面的入门篇——单例模式。学习这些模式有助于经验不足...

良知犹存的博客 342

02设计模式——单例模式

单例模式

ly000666的博客 206

设计模式 —— 单例模式

目录 一、什么是单例设计模式? 二、单例设计模式实现形式 1、饿汉式实现方式一(推荐) 2、饿汉式实现方式一 3、懒汉式实现方式一(线程不安全) 4、懒汉式实现方式二(线程安全,但效率低) 5、懒汉实现方式三(线程不安全) 6、懒汉实现方式四 - DCL 双端检查 + volatile(线程安全) 7、静态内部类方式,JVM 保证单例(推荐) 8、通过枚举实现单例模式(不推荐) 一、什么是单例设计模式? 单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的.

认知 行动 坚持 852
上一篇: DevOps-SRE岗位到底是什么?
下一篇: 是什么决定了一个项目是否成功?
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Seven的代码实验室

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值