「java单利饿汉」java单例模式懒汉和饿汉

本篇文章给大家谈谈java单利饿汉，以及java单例模式懒汉和饿汉对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java常用的几种单例模式（懒汉式，饿汉式
• 2、单例模式——懒汉式和饿汉式详解
• 3、手写单例模式（饿汉和饱汉模式）和工厂模式
• 4、java饿汉式单例设计模式
• 5、java 在单例模式饿汉式中使用成员变量是线程安全的吗？
• 6、Java单例模式饿汉式会有线程安全问题吗

java常用的几种单例模式（懒汉式，饿汉式

单件模式用途：

单件模式属于工厂模式的特例，只是它不需要输入参数并且始终返回同一对象的引用。

单件模式能够保证某一类型对象在系统中的唯一性，即某类在系统中只有一个实例。它的用途十分广泛，打个比方，我们开发了一个简单的留言板，用户的每一次留言都要将留言信息写入到数据库中，最直观的方法是没次写入都建立一个数据库的链接。这是个简单的方法，在不考虑并发的时候这也是个不错的选择。但实际上，一个网站是并发的，并且有可能是存在大量并发操作的。如果我们对每次写入都创建一个数据库连接，那么很容易的系统会出现瓶颈，系统的精力将会很多的放在维护链接上而非直接查询操作上。这显然是不可取的。

如果我们能够保证系统中自始至终只有唯一一个数据库连接对象，显然我们会节省很多内存开销和cpu利用率。这就是单件模式的用途。当然单件模式不仅仅只用于这样的情况。在《设计模式：可复用面向对象软件的基础》一书中对单件模式的适用性有如下描述：

1、当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

2、当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

下面对单件模式的懒汉式与饿汉式进行简单介绍：

1、饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。

2、懒汉式：当程序第一次访问单件模式实例时才进行创建。

如何选择：如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。

单例模式——懒汉式和饿汉式详解

单例模式属于 创建型模式 的一种，应用于保证一个类仅有一个实例的场景下，并且提供了一个访问它的全局访问点，如spring中的全局访问点BeanFactory，spring下所有的bean都是单例。

单例模式的特点：从系统启动到终止，整个过程只会产生一个实例。

单例模式常用写法：懒汉式，饿汉式，注册式，序列化式。

下面比较一下懒汉式和饿汉式：

懒汉式 ：默认不会实例化，什么时候用什么时候new。

public class Lazy{

        private Lazy(){}

        //默认不会实例化，什么时候用什么时候new

        private static Lazy lazy = null;

        public static synchronized Lazy getInstance(){

            if(lazy==null){

                lazy = new Lazy();

            }

            return lazy;

        }

}

饿汉式 ：类加载的时候就 实例化 ，并且创建单例对象。

public class Hungry{

        private Hungry(){}

        // 类加载的时候就实例化，并且创建单例对象

        private static final Hungry hungry = new Hungry();

        public static Hungry getInstance(){

                return hungry;

        }

}

懒汉式默认不会 实例化 ，外部什么时候调用什么时候new。

饿汉式在类加载的时候就实例化，并且创建单例对象。

饿汉式：线程安全。

在线程还没出现之前 就已经实例化了，因此饿汉式线程一定是安全的。

懒汉式：线程不安全。 

因为懒汉式加载是在使用时 才会去new 实例的，

那么你去new的时候是一个动态的过程，是放到方法中实现的。

比如：

public static synchronized Lazy getInstance(){  

         if(lazy==null){  

                lazy=new Lazy(); 

        } 

}

如果这个时候有多个线程访问这个实例 （这个时候实例还不存在，还在new），

就会进入到方法中，有多少线程就会new出多少个实例。

一个方法return一个实例，那最终return出哪个呢？

是不是会覆盖很多new的实例？

这种情况当然也可以解决，那就是 加同步锁 ，避免这种情况发生 。

饿汉式没有加任何的锁，因此执行效率比较高。

懒汉式一般使用都会加同步锁，效率比饿汉式差。

饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，

所以会占据空间，浪费内存。

懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。

手写单例模式（饿汉和饱汉模式）和工厂模式

 (1)单例饿汉模式://饿汉式单例类.在类初始化时，已经自行实例化 

public class Singleton1

{  //私有的默认构造子

private Singleton1() {}  //已经自行实例化 

 private static final Singleton1 single = new Singleton1();  //静态工厂方法 

 public static Singleton1 getInstance() { return single;  } }

（2）懒汉模式://懒汉式单例类.在第一次调用的时候实例化 

Java初高级一起学习分享，共同学习才是最明智的选择，喜欢的话可以我的学习群64弍46衣3凌9，或加资料群69似64陆0吧3（进群备注平台名）

 public class Singleton2

{  //私有的默认构造子 

private Singleton2() {}  //注意，这里没有final 

 private static Singleton2 single=null;  //静态工厂方法 

 public synchronized static Singleton2 getInstance() {  if (single == null) { single = new Singleton2();  }  return single;  }  }

(3)工厂模式:

interface IFactory{ public IProduct createProduct();}

Class Factory implements IFactory{ public IProduct createProduct(){return new Product();}}

Public class client

{ Public Static void main (String [] args)

{IFactory factory=new Factory(); IProduct product=factory.createProduct(); product.ProductMethod();}}

java饿汉式单例设计模式

因为是静态变量 static Single s 所以类加载即被创建该变量s指向new Single() ，当调用getInstance时返回s对象。

因为该s对象属于静态成员变量存在方法区而不是在堆栈中。方法区存储的东西只有一份。所以即使String b=Single.getInstance().返回的仍然是方法区中的唯一的静态变量s。即单例模式只有一个静态变量s指向该对象。不管怎么调用都只有一个该对象。

java 在单例模式饿汉式中使用成员变量是线程安全的吗？

你好，很高兴回答你的问题。

如果没有做同步处理，是线程不安全的。

获取单例对象的方法需要做同步处理。

如果有帮助到你，请点击采纳。

Java单例模式饿汉式会有线程安全问题吗

标准的答案!饿汉式没有线程安全问题，懒汉式需要双重锁定解决可能的线程安全问题。

饿汉式的缺点是类一加载就实例化，提前占用系统资源

java单利饿汉的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java单例模式懒汉和饿汉、java单利饿汉的信息别忘了在本站进行查找喔。