精华内容
下载资源
问答
  • java单例模式实例

    2018-07-17 18:51:20
    一个简单的java工程,包含注释,一目了然,其中包含了单例模式的所有实现方式,懒汉式,饿汉式,双重校验,枚举,静态内部类等方式实现单例
  • 主要介绍了Java单例模式实现静态内部类方法示例,涉及构造函数私有化等相关内容,需要的朋友可以了解下。
  • 深入分析java单例模式什么是单例模式单例模式的常见写法一、饿汉式单例优点缺点示例二、懒汉式单例示例1(普通写法)示例2(synchronized写法)示例3(DCL写法)示例4(内部类写法)三、注册式单例示例1(容器式)示例2(枚举式...
  • Java 单例模式 工具类

    2019-07-13 02:19:40
    源码 博文链接:https://tianlihu.iteye.com/blog/747737
  • 主要给大家介绍了关于Java单例模式推荐的两种模式,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要介绍了9种Java单例模式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java单例模式实现的几种方式的相关资料,需要的朋友可以参考下
  • Java单例模式深入理解

    2015-04-15 19:43:53
    不同单例模式的详细讲解,了解使用单例的最佳方式。
  • Java单例模式设计

    2018-05-15 16:09:46
    代码中演示了Java设计模式中的单例模式,其中包括饿汉单例模式,懒汉单例模式以及序列化饭序列化单例模式。在实际的开发中,可以直接借鉴使用。
  • 主要介绍了Java单例模式和多例模式,结合实例形式分析了java单例模式与多例模式的定义及使用技巧,需要的朋友可以参考下
  • 主要介绍了java单例模式使用及注意事项,需要的朋友可以参考下
  • java单例模式

    2021-03-06 06:25:11
    单例模式就是始终是一个对象实例.它对外不提供构造函数,因此我们不能够同时产生多个对象.(常用语工具类,数据库连接类等等)单例模式的调用:因为单例模式的构造方法是私有的,所以在其他类中我们是没有办法直接实例化它...

    单例模式

    就是始终是一个对象实例.它对外不提供构造函数,因此我们不能够同时产生多个对象.(常用语工具类,数据库连接类等等)

    单例模式的调用:因为单例模式的构造方法是私有的,所以在其他类中我们是没有办法直接实例化它的.但是又因为她对外提供了一个获取类实例的方法,所以不论有多少类调用,他对外只可能产生一个类的实例

    在People类中;创建静态私有对象p;创建getInstance()方法来返回对象p;其他类可以直接调用getInstance()方法获取对象p。

    1.饿汉单例模式:即静态初始化的方式,它是类一加载就实例化对象,所以要提前占用系统资源,因此线程安全

    public class People{

    private static People p = new People();

    private People(){

    }

    public static People getInstance(){

    return p;

    }

    }

    2.懒汉单例模式 : 它使用了延迟加载来保证对象在没有使用之前,是不会进行初始化的。

    缺点:线程不安全,当多个线程运行到getInstance()时,有可能会创建多个实例。

    public class People{

    private static People p;

    private People(){

    }

    public static People getInstance(){

    if(p == null){

    p = new People();

    }

    return p;

    }

    }

    3.我们可以直接加上synchronized ,实现线程同步

    classSingletion {private static Singletion singletion = null;privateSingletion() {

    }public static synchronizedSingletion getSingletion() {if (null ==singletion) {

    singletion= newSingletion();

    }returnsingletion;

    }

    }

    实现同步会一定程度的使程序的并发度降低,我们可以在对此进行改进。

    4.通过双重检查锁来保证程序的高并发和线程安全

    1 classSingletion{2 private static Singletion singletion=null;3

    4 privateSingletion() {5 }6 public staticSingletion getSingletion(){7 if(null==singletion){8 synchronized (Singletion.class){9 if(null==singletion){10 singletion=newSingletion();11 }12 }13 }14 returnsingletion;15 }16 }

    这种写法使得只有在加载新的对象进行同步,在加载完了之后,其他线程在第7行就可以判断跳过锁的的代价直接到第14行代码了。做到很好的并发度。

    5.利用枚举实现线程安全并且JVM安全的单例模式

    //线程安全,JVM安全的单例类

    enumSingleton{

    SINGLE

    }//单例类的使用

    classTest{public static voidmain(String[] args) {

    Singleton s1=Singleton.SINGLE;

    Singleton s2=Singleton.SINGLE;

    Singleton s3=Singleton.SINGLE;

    }

    }

    6.用内部类实现线程安全的单例模式

    classSingleton{//02 定义一个静态内部类

    private static classInnerClass{static Singleton singleton=newSingleton();

    }//03

    public staticSingleton getsingleton(){returnInnerClass.singleton;

    }//01

    privateSingleton(){

    System.out.println("call Singleton()");

    }

    }

    展开全文
  • 各个资料都在一个WORD钟,代码全面,复制粘贴即可运行
  • JAVA单例模式

    2021-02-12 18:32:20
    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。类型:创建类模式类图:类图知识点:1....单例模式应该是23种设计模式中最简单的一种模式了。它有以下几个要素:• 私有的...

    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

    类型:创建类模式

    类图:

    ad8ca4dabff6c1e0041507e951d2372c.png

    类图知识点:

    1.类图分为三部分,依次是类名、属性、方法

    2.以<>结尾的为注释信息

    3.修饰符+代表public,-代表private,#代表protected,什么都没有代表包可见。

    4.带下划线的属性或方法代表是静态的。

    单例模式应该是23种设计模式中最简单的一种模式了。它有以下几个要素:

    • 私有的构造方法

    • 指向自己实例的私有静态引用

    • 以自己实例为返回值的静态的公有的方法

    单例模式根据实例化对象时机的不同分为两种:一种是饿汉式单例,一种是懒汉式单例。饿汉式单例在单例类被

    加载时候,就实例化一个对象交给自己的引用;而懒汉式在调用取得实例方法的时候才会实例化对象。代码如

    下:

    饿汉式单例

    public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){

    return singleton;

    }

    }

    懒汉式单例

    public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    public static synchronized Singleton getInstance(){

    if(singleton==null){

    singleton = new Singleton();

    }

    return singleton;

    }

    }

    单例模式的优点:

    • 在内存中只有一个对象,节省内存空间。

    • 避免频繁的创建销毁对象,可以提高性能。

    • 避免对共享资源的多重占用。

    • 可以全局访问。

    适用场景:由于单例模式的以上优点,所以是编程中用的比较多的一种设计模式。我总结了一下我所知道的适合

    使用单例模式的场景:

    • 需要频繁实例化然后销毁的对象。

    • 创建对象时耗时过多或者耗资源过多,但又经常用到的对象。

    • 有状态的工具类对象。

    • 频繁访问数据库或文件的对象。

    • 以及其他我没用过的所有要求只有一个对象的场景。

    单例模式注意事项:

    • 只能使用单例类提供的方法得到单例对象,不要使用反射,否则将会实例化一个新对象。

    • 不要做断开单例类对象与类中静态引用的危险操作。

    • 多线程使用单例使用共享资源时,注意线程安全问题。

    在一个jvm中会出现多个单例吗??

    在分布式系统、多个类加载器、以及序列化的的情况下,会产生多个单例,这一点是无庸置疑的。那么在同一个j

    vm中,会不会产生单例呢?使用单例提供的getInstance()方法只能得到同一个单例,除非是使用反射方式,将

    会得到新的单例。代码如下

    Class c = Class.forName(Singleton.class.getName());

    Constructor ct = c.getDeclaredConstructor();

    ct.setAccessible(true);

    Singleton singleton = (Singleton)ct.newInstance();

    懒汉式单例线程安全吗

    主要是网上的一些说法,懒汉式的单例模式是线程不安全的,即使是在实例化对象的方法上加synchronized关键

    字,也依然是危险的,但是笔者经过编码测试,发现加synchronized关键字修饰后,虽然对性能有部分影响,但

    是却是线程安全的,并不会产生实例化多个对象的情况。

    单例模式只有饿汉式和懒汉式两种吗

    饿汉式单例和懒汉式单例只是两种比较主流和常用的单例模式方法,从理论上讲,任何可以实现一个类只有一个

    实例的设计模式,都可以称为单例模式。

    单例类可以被继承吗

    饿汉式单例和懒汉式单例由于构造方法是private的,所以他们都是不可继承的,但是其他很多单例模式是可以继

    承的,例如登记式单例。

    饿汉式单例好还是懒汉式单例好

    在java中,饿汉式单例要优于懒汉式单例。C++中则一般使用懒汉式单例。

    展开全文
  • 主要介绍了Java单例模式下的MongoDB数据库操作工具类,结合实例形式分析了java基于单例模式下操作MongoDB数据库相关连接、查询、插入、删除等操作封装技巧,需要的朋友可以参考下
  • java单例模式连接数据库源码.可以直接引用只需加入相应的mysql 或 oracle的驱动,修改源码的连接地址用户名及密码。
  • java 单例模式的好处

    2021-02-25 19:11:19
    单例模式是一种常见的设计模式,在《Java与模式》一书中,阎宏博士对单例模式做了全面的总结。单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。单例模式有一下特点:1、单例类只能有一个实例。2、单例类...

    单例模式是一种常见的设计模式,在《Java与模式》一书中,阎宏博士对单例模式做了全面的总结。

    单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。

    单例模式有一下特点:

    1、单例类只能有一个实例。

    2、单例类必须自己创建自己的唯一实例。

    3、单例类必须给所有其他对象提供这一实例。

    说明:一下的代码来自阎宏博士的《Java与模式》一书,其中对一些类的写法做调整(符合Java1.5的习惯),另外还加了测试方法。

    一、懒汉式单例

    在类被加载的时候,唯一实例已经被创建。这个设计模式在Java中容易实现,在别的语言中难以实现。

    /**

    * Created by IntelliJ IDEA.

    * User: leizhimin

    * Date: 2007-9-11

    * Time: 14:57:08

    * <> 单例模式-懒汉式单例

    */

    public class LazySingleton {

    /**

    * 私有静态对象,加载时候不做初始化

    */

    private static LazySingleton m_intance=null;

    /**

    * 私有构造方法,避免外部创建实例

    */

    private LazySingleton(){

    }

    /**

    * 静态工厂方法,返回此类的唯一实例.

    * 当发现实例没有初始化的时候,才初始化.

    * @return LazySingleton

    */

    synchronized public static LazySingleton getInstance(){

    if(m_intance==null){

    m_intance=new LazySingleton();

    }

    return m_intance;

    }

    }

    二、饿汉式单例

    在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建,并且只在第一次创建后,以后不再创建该类的实例。

    /**

    * Created by IntelliJ IDEA.

    * User: leizhimin

    * Date: 2007-9-11

    * Time: 14:45:25

    * <> 单例模式-饿汉式单例

    */

    public class EagerSingleton {

    /**

    * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象

    */

    private static final EagerSingleton m_instance = new EagerSingleton();

    /**

    * 私有构造方法,避免外部创建实例

    */

    private EagerSingleton() {

    }

    /**

    * 静态工厂方法,返回此类的唯一实例.

    * @return EagerSingleton

    */

    public static EagerSingleton getInstance() {

    return m_instance;

    }

    }

    三、登记式单例

    这个单例实际上维护的是一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从工厂直接返回,对于没有登记的,则先登记,而后返回。

    /**

    * Created by IntelliJ IDEA.

    * User: leizhimin

    * Date: 2005-9-11

    * Time: 15:20:16

    * <> 单例模式- 登记式单例

    */

    public class RegSingleton {

    /**

    * 登记薄,用来存放所有登记的实例

    */

    private static Mapm_registry = new HashMap();

    //在类加载的时候添加一个实例到登记薄

    static {

    RegSingleton x = new RegSingleton();

    m_registry.put(x.getClass().getName(), x);

    }

    /**

    * 受保护的默认构造方法

    */

    protected RegSingleton() {

    }

    /**

    * 静态工厂方法,返回指定登记对象的唯一实例;

    * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回

    * @param name

    * @return RegSingleton

    */

    public static RegSingleton getInstance(String name) {

    if (name == null) {

    name = "RegSingleton";

    }

    if (m_registry.get(name) == null) {

    try {

    m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());

    } catch (InstantiationException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    } catch (ClassNotFoundException e) {

    e.printStackTrace();

    }

    }

    return m_registry.get(name);

    }

    /**

    * 一个示意性的商业方法

    * @return String

    */

    public String about() {

    return "Hello,I am RegSingleton!";

    }

    }

    展开全文
  • java单例模式——详解JAVA单例模式及8种实现方式

    万次阅读 多人点赞 2020-10-23 15:39:01
    ## 单例模式是最简单也是最基础的设计模式之一,下边一起学习一下单例模式! 一.单例模式的定义: 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志...

    ## 单例模式是最简单也是最基础的设计模式之一,下边一起学习一下单例模式!

    一.单例模式的定义:
    单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态,避免政出多头。

    二.单例模式的特点
     1、单例类只能有一个实例。
     2、单例类必须自己创建自己的唯一实例。
     3、单例类必须给所有其他对象提供这一实例。
    单例模式保证了全局对象的唯一性,比如系统启动读取配置文件就需要单例保证配置的一致性。

    三.线程安全问题:
    一方面在获取单例的时候,要保证不能产生多个实例对象,后面会详细讲到五种实现方式;
    另一方面,在使用单例对象的时候,要注意单例对象内的实例变量是会被多线程共享的,推荐使用无状态的对象,不会因为多个线程的交替调度而破坏自身状态导致线程安全问题,比如我们常用的VO,DTO等(局部变量是在用户栈中的,而且用户栈本身就是线程私有的内存区域,所以不存在线程安全问题)。

    四.实现单例模式的八种方式:
    1.饿汉式(静态常量)【可用】
    优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
    缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费。
    在这里插入图片描述

    2.饿汉式(静态代码块)【可用】
    这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
    在这里插入图片描述

    3.懒汉式(线程不安全)【不可用】
    这种写法起到了Lazy Loading的效果,但是只能在单线程下使用。如果在多线程下,一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
    在这里插入图片描述

    4.懒汉式(线程安全,同步方法)【不推荐用】
    解决上面第三种实现方式的线程不安全问题,做个线程同步就可以了,于是就对getInstance()方法进行了线程同步。
    缺点:效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低要改进。
    在这里插入图片描述

    5.懒汉式(线程安全,同步代码块)【不可用】
    由于第四种实现方式同步效率太低,所以摒弃同步方法,改为同步产生实例化的的代码块。但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致,假如一个线程进入了if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。
    在这里插入图片描述

    6.双重检查【推荐使用】
    Double-Check概念对于多线程开发者来说不会陌生,如代码中所示,我们进行了两次if (singleton == null)检查,这样就可以保证线程安全了。这样,实例化代码只用执行一次,后面再次访问时,判断if (singleton == null),直接return实例化对象。
    优点:线程安全;延迟加载;效率较高。
    在这里插入图片描述

    7.静态内部类【推荐使用】
    这种方式跟饿汉式方式采用的机制类似,但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化,没有Lazy-Loading的作用,而静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance方法,才会装载SingletonInstance类,从而完成Singleton的实例化。
    类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
    优点:避免了线程不安全,延迟加载,效率高。
    在这里插入图片描述

    8.枚举【推荐使用】
    借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
    在这里插入图片描述

    五.单例模式的优点
    系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。
    六.单例模式的缺点
    当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new,可能会给其他开发人员造成困扰,特别是看不到源码的时候。
    七.单例模式的使用场景
    • 需要频繁的进行创建和销毁的对象;
    • 创建对象时耗时过多或耗费资源过多,但又经常用到的对象;
    • 工具类对象;
    • 频繁访问数据库或文件的对象。

    展开全文
  • } } 由于单例的静态特性使得其生命周期和应用的生命周期一样长,如果一个对象已经不再需要使用了,而单例对象还持有该对象的引用,就会使得该对象不能被正常回收,从而导致了内存泄漏。 实用的Bean工厂...
  • Java单例设计模式是GoF23种设计模式之一,也是是使用频率最高的设计模式之一,所以想参加java程序员岗位面试的朋友们,必须要提前学习好java单例模式面试题的内容,java单例模式在初级中高级的面试中几乎都会出现,...
  • Java单例模式简单示例

    2020-08-30 04:12:59
    主要介绍了Java单例模式,结合实例形式简单分析了java单例模式的定义与使用技巧,需要的朋友可以参考下
  • Java单例 与 继承

    2020-03-23 15:46:09
    单例对象的类必须保证只有一个实例存在——这是维基百科上对单例的定义,这也可以作为对意图实现单例模式的代码进行检验的标准。 对单例的实现可以分为两大类——懒汉式和饿汉式,他们的区别在于: 懒汉式:指全局的...
  • Java连接数据库 JavaDevelopmentKit Version11,MYSQL Version 8.0。 创建的这个工具类名字叫做DBUtil类 private Connection connection = null; private Statement statement = null; private ResultSet ...
  • 为了保证jvm中某一类型的java对象永远只有一个,同时也是为了节省内存的开销。因为外面程序可以通过new的方法直接调用类里面的构造方法。导致该类的对象不止一个。2)定义单例模式的意思就是只有一个实例。单例模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 283,286
精华内容 113,314
关键字:

java单例

java 订阅
友情链接: Routh.rar