创建模式之—单例、多例

我的版本：（分为多例和单例）

 

---

单例：

 

      概念：一个类只对外提供一个实例

 

      目的：减少对象的产生，提高对象的复用性（利用率）

 

    条件：1、自己关联自己

             2、拥有私有的构造方法

             3、拥有提供自己对象的方法

 

      图像：

          

代码：

 

/**

 * Class

 *

 * @author ANDY

 *

 *         2012 -9- 1 上午4:02:50

 *

 *         登录类

 */

public class Login {

       /**

       * 静态的登录类自己

       */

       private static Login login = new Login();

 

       /**

       * Constructors

       *

       * 私有的构成方法

       */

       private Login() {

      }

 

       /**

       * Methods

       *

       * @return 登录自己

       * 得到自己的静态方法

       */

       public static Login getMe() {

             return login ;

      }

 

       /**

       * Methods

       *

       * @param name

       * @return

       * 登录方法

       */

       public Boolean login(String name) {

             boolean flag = false;

             if (name.equals("andy" )) {

                  flag = true;

            }

             return flag;

      }

}

/**

 * Class

 *

 * @author ANDY

 *

 *         2012 -9- 1 上午4:05:33

 *

 *         用户类

 */

public class User {

 

       /**

       * Methods

       *

       * @param args

       *            测试方法

       */

       public static void main(String[] args) {

             if (Login.getMe().login( "andy")) {

                  System. out.println("用户名正确" );

            } else {

                  System. out.println("用户名错误" );

            }

 

      }

}

 

---

 

多例：

 

      概念：对外提供多个对象以供不同的选择

 

       目的：针对不同的情况提供不同的实例（如国际化）

 

   条件：1、自己关联多个自己

             2、拥有私有的构造方法

             3、拥有提供自己对象的方法

 

      图像：

 

            

代码：

 

import java.util.Random;

 

/**

 * Class

 *

 * @author ANDY

 *

 *         2012 -9- 1 上午3:51:03

 *

 *         骰子

 */

public class Dice {

       /**

       * 第一个静态的自己实例

       */

       private static Dice dice1 = new Dice();

       /**

       * 第二个静态的自己实例

       */

       private static Dice dice2 = new Dice();

 

       /**

       * Constructors

       *

       * 私有的构造方法

       */

       private Dice() {

      }

 

       /**

       * Methods

       *

       * @param i

       * @return 骰子

       * 得到自己的方法

       */

       public static Dice getMe(int i) {

             if (i == 1) {

                   return dice1 ;

            } else {

                   return dice2 ;

            }

      }

 

       /**

       * Methods

       *

       * @return 骰子点数

       * 玩骰子

       */

       public int playDice() {

             int index = 0;

            Random r = new Random();

            index = r.nextInt(6) + 1;

             return index;

      }

}

/**

 * Class

 *

 * @author ANDY

 *

 *         2012 -9- 1 上午3:49:42

 *

 *         玩家

 */

public class Player {

       /**

       * Methods

       *

       * @param args

       *            测试方法玩家玩两个骰子

       */

       public static void main(String[] args) {

            System. out.println(Dice.getMe(1).playDice());

            System. out.println(Dice.getMe(2).playDice());

      }

}

 

---

 

网络版本之一：

单态定义:

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，



Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。


如何使用?
一般Singleton模式通常有几种形式:

public class Singleton {

  private Singleton(){}

  //在自己内部定义自己一个实例，是不是很奇怪？
  //注意这是private 只供内部调用

  private static Singleton instance = new Singleton();

  //这里提供了一个供外部访问本class的静态方法，可以直接访问 
  public static Singleton getInstance() {
    return instance;  
   }
}




第二种形式:

public class Singleton {
  private static Singleton instance = null;

  public static synchronized Singleton getInstance() {

  if (instance==null)
    instance＝new Singleton();
  return instance;   }

}




使用Singleton.getInstance()可以访问单态类。

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

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。
-



使用Singleton注意事项：
有时在某些情况下，使用Singleton并不能达到Singleton的目的，如有多个Singleton对象同时被不同的类装入器装载；在EJB这样的分布式系统中使用也要注意这种情况，因为EJB是跨服务器，跨JVM的。

我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator为例稍微分析一下：

在Pet Store中ServiceLocator有两种，一个是EJB目录下；一个是WEB目录下，我们检查这两个ServiceLocator会发现内容差不多，都是提供EJB的查询定位服务，可是为什么要分开呢？仔细研究对这两种ServiceLocator才发现区别：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator属于资源定位，理所当然应该使用Singleton模式。但是在EJB中，Singleton模式已经失去作用，所以ServiceLocator才分成两种，一种面向WEB服务的，一种是面向EJB服务的。

Singleton模式看起来简单，使用方法也很方便，但是真正用好，是非常不容易，需要对Java的类 线程 内存等概念有相当的了解。

总之：如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术。

---

 

网络版本之二：

单例模式，其实这个模式运用时相当广泛的，如果仁兄你可能不懂设计模式，但是你的代码中却可能用过单例模式。单例模式的关键点就在单。从某些方面来说，我们可以把常量看过一种单例模式，即单例模式只有一个实例，每次引用都是相同的对象。
在GOF中，单例模式是创建型模型，对于单例模式，我们一般基于一个全局变量来实现：

1. public class People        //类名 
2.    { 
3.        private static string name;    //字段 
4.  
5.        private People() //构造函数 
6.        { 
7.  
8.        } 
9.  
10.        public static string GetName()    // 函数 
11.        { 
12.            if (string.IsNullOrEmpty(name)) 
13.            { 
14.                name = "my name"; 
15.            } 
16.            return name; 
17.  
18.  
19.        } 
20.  
21.  
22.  
23.    } 

在上述代码中我们通过一个static变量和私有构造函数来保证我们通过GetName函数取的值是同一个字符串。

String类型虽然是值类型的，但是只不过是将原本引用类型的string经过特殊处理让他具备值类型的特点而已，在这里我们依然将其当做引用类型。

另外，单例模式和享元模式是不同的：

1. 享元模式是结构型模式，单例模式是创建型模式
2. 单例模式是保证对象的唯一的实例，而享元模式是让每个轻量级的对象在内存中只有一个，实现过程中主要是要为共享对象提供一个存放的“仓库”（对象池）。