java代码单例模式两种 java单例模式和多例模式

java开发在什么情况下使用单例模式？

使用原则如下：

创新互联建站主要从事成都做网站、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务雅安,十年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

1.单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例

2.单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）

单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。

比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

单例模式有哪两种设计方法，用文字和代码分别说明

　单例模式(Singleton) ,属于最常见的设计模式之一，大部分系统都会用到，目的是为了维护系统中唯一的一个实例。

可分为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{

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单例模式有哪些？

一、懒汉式单例\x0d\x0a在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。\x0d\x0a \x0d\x0apublic class LazySingleton {\x0d\x0a /**\x0d\x0a * 私有静态对象,加载时候不做初始化\x0d\x0a */\x0d\x0a private static LazySingleton m_intance=null;\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private LazySingleton(){\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例. \x0d\x0a * 当发现实例没有初始化的时候,才初始化.\x0d\x0a */\x0d\x0a synchronized public static LazySingleton getInstance(){\x0d\x0a if(m_intance==null){\x0d\x0a m_intance=new LazySingleton();\x0d\x0a }\x0d\x0a return 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\x0a private static final EagerSingleton m_instance = new EagerSingleton();\x0d\x0a /**\x0d\x0a * 私有构造方法,避免外部创建实例\x0d\x0a */\x0d\x0a private EagerSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回此类的唯一实例.\x0d\x0a * @return EagerSingleton\x0d\x0a */\x0d\x0a public static EagerSingleton getInstance() {\x0d\x0a return 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\x0a private static Map m_registry = new HashMap();\x0d\x0a //在类加载的时候添加一个实例到登记薄\x0d\x0a static {\x0d\x0a RegSingleton x = new RegSingleton();\x0d\x0a m_registry.put(x.getClass().getName(), x);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 受保护的默认构造方法\x0d\x0a */\x0d\x0a protected RegSingleton() {\x0d\x0a }\x0d\x0a /**\x0d\x0a * 静态工厂方法,返回指定登记对象的唯一实例;\x0d\x0a * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回\x0d\x0a * @param name\x0d\x0a * @return RegSingleton\x0d\x0a */\x0d\x0a public static RegSingleton getInstance(String name) {\x0d\x0a if (name == null) {\x0d\x0a name = "RegSingleton";\x0d\x0a }\x0d\x0a if (m_registry.get(name) == null) {\x0d\x0a try {\x0d\x0a m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());\x0d\x0a } catch (InstantiationException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (IllegalAccessException e) {\x0d\x0a e.printStackTrace();\x0d\x0a } catch (ClassNotFoundException e) {\x0d\x0a e.printStackTrace();\x0d\x0a }\x0d\x0a }\x0d\x0a return m_registry.get(name);\x0d\x0a }\x0d\x0a /**\x0d\x0a * 一个示意性的商业方法\x0d\x0a * @return String\x0d\x0a */\x0d\x0a public String about() {\x0d\x0a return "Hello,I am RegSingleton!";\x0d\x0a }\x0d\x0a}

什么是Java单例模式啊？

楼主您好

java模式之单例模式：

单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。

特点：

1，一个类只能有一个实例

2，自己创建这个实例

3，整个系统都要使用这个实例

例: 在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。一些资源管理器常常设计成单例模式。

外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。

一个例子：Windows 回收站。

在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。

两种形式：

1，饿汉式单例类

public class Singleton {

private Singleton(){}

//在自己内部定义自己一个实例，是不是很奇怪？

//注意这是private 只供内部调用

private static Singleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

}

}

2，懒汉式单例类

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if (instance==null)

instance＝new Singleton();

return instance; }

}

第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

网站标题：java代码单例模式两种 java单例模式和多例模式
URL链接：http://cdiso.cn/article/hgogdi.html