java单例模式代码 java中单例模式的实现 _实例

如何写一个简单的单例模式？一、基本的实现思路:
单例的实现主要是通过以下两个步骤：
1、将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
2、在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。
二、示范如下：
1、枚举实现单例：
2、懒汉式线程不安全：
3、懒汉式线程安全：
4、饿汉式：
5、双重校验锁：
6、静态内部类：
扩展资料:
一、单列模式简介：
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。
二、懒汉与饿汉：
1、懒汉方式：指全局的单例实例在第一次被使用时构建。
2、饿汉方式：指全局的单例实例在类装载时构建。
三、单例模式的三要点：
1、某个类只能有一个实例。
2、它必须自行创建这个实例。
3、它必须自行向整个系统提供这个实例。
四、优缺点：
1、优点：
①实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
②灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。
2、缺点：
①开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
②可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
③对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。
参考资料：百度百科单列模式
单例模式代码怎么写？　单例模式(Singleton) ,属于最常见的设计模式之一java单例模式代码，大部分系统都会用到java单例模式代码，目的是为java单例模式代码了维护系统中唯一的一个实例。
可分为eager模式，示例代码如下：
Java代码
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代码如下：
Java代码
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源码中，Runtime.getRuntime()就是单例的一个例子。
单例模式的精神就是整个系统中维护一个实例，推广开来，如果在一个系统中需要维护多个示例，那么就产生了多例模式(multiton) 。
多例模式(Multiton) ,通过聚集对象了保留自身的多个示例，根据客户端的参数返回所需要的实例。
示例代码如下：
Java代码
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
【java单例模式代码 java中单例模式的实现】private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一个实用的例子就是KeyGenerator, 示例代码如下：
Java代码
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}
java单例模式怎么创建对象1. 说明
1）单例模式java单例模式代码：确保一个类只有一个实例java单例模式代码，自行实例化并向系统提供这个实例
2）单例模式分类：饿单例模式（类加载时实例化一个对象给自己java单例模式代码的引用）java单例模式代码，懒单例模式（调用取得实例java单例模式代码的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式， c中一般使用懒单例模式）
3）单例模式要素：
a）私有构造方法
b）私有静态引用指向自己实例
c）以自己实例为返回值的公有静态方法
2.实例
饿单例模式：
复制代码代码如下:
package com.wish.modedesign;
public class HungrySingleton {
private static HungrySingleton instance= new HungrySingleton();
private HungrySingleton(){
}
public static HungrySingleton getInstance(){
return instance;
}
JAVA static 单例模式单例模式可以理解为是面向对象语言中对全局变量java单例模式代码的一种实现java单例模式代码，当然的作用不仅仅限于此。我们可以对单例模式实现的过程中的思路进行一下剖析，如此更加清楚的认识到设计模式究竟是什么，当然也可以证明一下基础知识的重要性（基础才是王道）。
首先我们分析一下单例的意义，在Java中为一个类只能有一个实例化对象。这显然不是我们平常所写的一个普通类所能够做到的事情。那么为了实现这一个要求该如何去做呢。实例化是一个类的初始化时候的问题，而初始化是构造方法去做的事情（当然这里面jvm也帮我们做了很多的事情）。构造方法，我们要设为私有。这样我们让该类不能被随意的初始化，那该在哪初始化，而它有怎样被调用呢。
一个不能初始化的类，也就是说不能够被实例化的类，我们想要调用。那么无疑让我们想到了static关键字，一个public static 的方法可以实现我们这个要求——即在不实例化类的情况下能够调用其中的方法。于是我们写下了一个public static 的方法，用于得到这个类的唯一实例。而这个实例我们是在类的内部实例，并同样定义为 static 的变量（一直用static 只是为了能够不实例化便可以使用。因为static可以在类初始化的时候便生成了，对于此不理解的同学们可以查看我的前一篇博客。。。）。到这里我们一个单例模式的实现框架其实已经搭好了。
java开发什么情况下使用单例模式？java单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。\x0d\x0a特点：\x0d\x0a1，一个类只能有一个实例；\x0d\x0a2，自己创建这个实例；\x0d\x0a3 ，整个系统都要使用这个实例。\x0d\x0a--------------------------------\x0d\x0aSingleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。\x0d\x0a外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。\x0d\x0a内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。\x0d\x0a--------------------------------\x0d\x0a单例模式，能避免实例重复创建；\x0d\x0a单例模式，应用于避免存在多个实例引起程序逻辑错误的场合；\x0d\x0a单例模式，较节约内存。
JAVA单例模式有哪些？一、懒汉式单例\x0d\x0a在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。\x0d\x0a \x0d\x0apublic class LazySingleton {\x0d\x0a/**\x0d\x0a* 私有静态对象,加载时候不做初始化\x0d\x0a*/\x0d\x0aprivate static LazySingleton m_intance=null;\x0d\x0a/**\x0d\x0a* 私有构造方法,避免外部创建实例\x0d\x0a*/\x0d\x0aprivate LazySingleton(){\x0d\x0a}\x0d\x0a/**\x0d\x0a* 静态工厂方法,返回此类的唯一实例.\x0d\x0a* 当发现实例没有初始化的时候,才初始化.\x0d\x0a*/\x0d\x0asynchronized public static LazySingleton getInstance(){\x0d\x0aif(m_intance==null){\x0d\x0am_intance=new LazySingleton();\x0d\x0a}\x0d\x0areturn m_intance;\x0d\x0a}\x0d\x0a}\x0d\x0a\x0d\x0a二、饿汉式单例\x0d\x0a在类被加载的时候，唯一实例已经被创建。\x0d\x0a \x0d\x0apublic class EagerSingleton {\x0d\x0a/**\x0d\x0a* 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象\x0d\x0a*/\x0d\x0aprivate static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0a/**\x0d\x0a* 私有构造方法,避免外部创建实例\x0d\x0a*/\x0d\x0aprivate EagerSingleton() {\x0d\x0a}\x0d\x0a/**\x0d\x0a* 静态工厂方法,返回此类的唯一实例.\x0d\x0a* @return EagerSingleton\x0d\x0a*/\x0d\x0apublic static EagerSingleton getInstance() {\x0d\x0areturn m_instance;\x0d\x0a}\x0d\x0a}\x0d\x0a \x0d\x0a**************************************************************************************懒汉方式，指全局的单例实例在第一次被使用时构建；\x0d\x0a饿汉方式，指全局的单例实例在类装载时构建\x0d\x0a**************************************************************************************\x0d\x0a\x0d\x0a三、登记式单例\x0d\x0a这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记?。┲?，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。\x0d\x0apublic class RegSingleton {\x0d\x0a/**\x0d\x0a* 登记薄,用来存放所有登记的实例\x0d\x0a*/\x0d\x0aprivate static Map m_registry = new HashMap();\x0d\x0a//在类加载的时候添加一个实例到登记薄\x0d\x0astatic {\x0d\x0aRegSingleton x = new RegSingleton();\x0d\x0am_registry.put(x.getClass().getName(), x);\x0d\x0a}\x0d\x0a/**\x0d\x0a* 受保护的默认构造方法\x0d\x0a*/\x0d\x0aprotected RegSingleton() {\x0d\x0a}\x0d\x0a/**\x0d\x0a* 静态工厂方法,返回指定登记对象的唯一实例;\x0d\x0a* 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回\x0d\x0a* @param name\x0d\x0a* @return RegSingleton\x0d\x0a*/\x0d\x0apublic static RegSingleton getInstance(String name) {\x0d\x0aif (name == null) {\x0d\x0aname = "RegSingleton";\x0d\x0a}\x0d\x0aif (m_registry.get(name) == null) {\x0d\x0atry {\x0d\x0am_registry.put(name, (RegSingleton) Class.forName(name).newInstance());\x0d\x0a} catch (InstantiationException e) {\x0d\x0ae.printStackTrace();\x0d\x0a} catch (IllegalAccessException e) {\x0d\x0ae.printStackTrace();\x0d\x0a} catch (ClassNotFoundException e) {\x0d\x0ae.printStackTrace();\x0d\x0a}\x0d\x0a}\x0d\x0areturn m_registry.get(name);\x0d\x0a}\x0d\x0a/**\x0d\x0a* 一个示意性的商业方法\x0d\x0a* @return String\x0d\x0a*/\x0d\x0apublic String about() {\x0d\x0areturn "Hello,I am RegSingleton!";\x0d\x0a}\x0d\x0a}
关于java单例模式代码和java中单例模式的实现的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

java单例模式代码 java中单例模式的实现

推荐阅读

prc是什么国家的缩写

给弟弟做作业

苹果12夜间模式怎么设置苹果12夜间模式怎么设置?

谁定的古代四大发明？为何不是笔墨纸砚？

菲斯曼壁挂炉待机模式怎么解除怎么解决？故障恢复常用方法

大象无形大音希声是什么意思大象无形大音希声的解释

微波雷达市场分析,汽车雷达市场分析

小学英语六年级试卷讲评课的教案试卷讲评课

信用卡逾期多久会打电话给家人信用卡逾期多久?

宝宝腹泻怎么推拿

翡翠可以做佛珠吗

鲍鱼烧土豆的家常做法鲍鱼烧土豆做法步骤

红心柚子苦了还能吃吗

最新难忘的母亲节中学生作文难忘的春节初中

水墨收藏的市场前景分析

新媒介数据分析与应用,媒介投放数据分析

销案和结案的区别你知道吗

双修ez该怎样出装？

吃奶后用什么方法可以使婴儿打嗝？

遇到火灾怎么办