单体模式Singleton

　　考试吧java站整理：

　　一，什么是单体模式

　　对象只要利用自己的属性完成了自己的任务，那该对象就是承担了责任。除了维持了自身的一致性，该对象无需承担其他任何责任。 如果该对象还承担着其他责任，而其他对象又依赖于该特定对象所承担的责任，我们就需要得到该特定对象。

　　将类的责任集中到唯一的单体对象中，确保该类只有一个实例，并且为该类提供一个全局访问点。这就是单体模式的目的。

　　单体模式的难点不在于单体模式的实现，而在于在系统中任何识别单体和保证单体的唯一性。

　　二，单体模式的实现

　　1,提供唯一的私有构造器，避免多个单体(Singleton)对象被创建，这也意味着该单体类不能有子类，那声明你的单例类为final是一个好主意，这样意图明确，并且让编译器去使用一些性能优化选项。 如果有子类的话使用protected，protected的构造方法可以被其子类以及在同一个包中的其它类调用。私有构造器可以防止客户程序员通过除由我们提供的方法之外的任意方式来创建一个实例,如果不把构造器声明为private或protected, 编译器会自动的创建一个public的构造函数。

　　2，使用静态域(static field)来维护实例。

　　将单体对象作为单体类的一个静态域实例化。 使用保存唯一实例的static变量，其类型就是单例类型本身。需要的话使用final，使其不能够被重载。

　　例如：private static Rutime currentRuntime = new Runtime();

　　3，使用静态方法(Static Method)来监视实例的创建。

　　a,加载时实例化

　　例如

　　view plaincopy to clipboardprint?

　　private static final Singleton Singleton _instance = new Singleton();

　　private Singleton() {

　　}

　　public static synchronized Singleton getInstance() {

　　return Singleton _instance;

　　}

　　}

　　public class Singleton {

　　private static final Singleton Singleton _instance = new Singleton();

　　private Singleton() {

　　}

　　public static synchronized Singleton getInstance() {

　　return Singleton _instance;

　　}

　　}

　　b,使用时实例化(惰性初始化)：这样做可以在运行时收集需要的信息来实例化单体对象，确保实例只有在需要时才被建立出来。

　　例如

　　view plaincopy to clipboardprint?

　　public class Singleton {

　　private static final Singleton Singleton _instance = null;

　　private Singleton() {

　　//使用运行时收集到的需要的信息,进行属性的初始化等操作。

　　}

　　public static synchronized Singleton getInstance() {

　　if (Singleton _instance == null){

　　Singleton _instance = new Singleton();

　　}

　　return Singleton _instance;

　　}

　　}

　　public class Singleton {

　　private static final Singleton Singleton _instance = null;

　　private Singleton() {

　　//使用运行时收集到的需要的信息,进行属性的初始化等操作。

　　}

　　public static synchronized Singleton getInstance() {

　　if (Singleton _instance == null){

　　Singleton _instance = new Singleton();

　　}

　　return Singleton _instance;

　　}

　　}

　　4，单体对象的成员变量(属性)：即单体对象的状态 通过单例对象的初始化来实现成员变量的初始化。 通过方法对单体对象的成员变量进行更新操作。

　　例如

　　view plaincopy to clipboardprint?

　　private static final Singleton Singleton _instance = null;

　　private Vector properties = null;

　　protected Singleton() {

　　//使用运行时收集到的需要的信息,进行属性的初始化等操作。

　　}

　　private static synchronized void syncInit() {

　　if (Singleton _instance == null) {

　　Singleton _instance = new Singleton();

　　}

　　}

　　public static Singleton getInstance() {

　　if (Singleton _instance == null){

　　syncInit();

　　}

　　return Singleton _instance;

　　}

　　public synchronized void updateProperties() {

　　// 更新属性的操作。

　　}

　　public Vector getProperties() {

　　return properties;

　　}

　　}

　　public class Singleton {

　　private static final Singleton Singleton _instance = null;

　　private Vector properties = null;

　　protected Singleton() {

　　//使用运行时收集到的需要的信息,进行属性的初始化等操作。

　　}

　　private static synchronized void syncInit() {

　　if (Singleton _instance == null) {

　　Singleton _instance = new Singleton();

　　}

　　}

　　public static Singleton getInstance() {

　　if (Singleton _instance == null){

　　syncInit();

　　}

　　return Singleton _instance;

　　}

　　public synchronized void updateProperties() {

　　// 更新属性的操作。

　　}

　　public Vector getProperties() {

　　return properties;

　　}

　　}||| 　　三，单体对象的同步(单体模式与多线程)

　　1，单体对象初始化同步

　　问题： 在多线程模式下，惰性初始化会使多个线程同时初始化该单体，造成一个JVM中多个单例类型的实例， 如果这个单例类型的成员变量在运行过程中发生变化，会造成多个单例类型实例的不一致。

　　解决的办法:（上面已经给出了例子） 加个同步修饰符: public static synchronized Singleton getInstance(). 这样就保证了线程的安全性. 这种处理方式虽然引入了同步代码，但是因为这段同步代码只会在最开始的时候执行一次或多次，所以对整个系统的性能不会有影响。

　　2，单体对象属性的同步

　　问题： 在更新属性的时候，会造成属性的读写不一致。

　　解决方法

　　1，读者/写者的处理方式 设置一个读计数器，每次读取信息前，将计数器加1，读完后将计数器减1。使用notifyAll()解除在该对象上调用wait的线程阻塞状态。只有在读计数器为0时，才能更新数据，同时调用wait()方法要阻塞所有读属性的调用。

　　2，采用"影子实例"的办法 具体说，就是在更新属性时，直接生成另一个单例对象实例， 这个新生成的单例对象实例将从数据库，文件或程序中读取最新的信息；然后将这些信息直接赋值给旧单例对象的属性。

　　例子：读者/写者的处理方式

　　view plaincopy to clipboardprint?

　　private static GlobalConfig instance;

　　private Vector properties = null;

　　private boolean isUpdating = false;

　　private int readCount = 0;

　　private GlobalConfig() {

　　//Load configuration information from DB or file

　　//Set values for properties

　　}

　　private static synchronized void syncInit() {

　　if (instance == null) {

　　instance = new GlobalConfig();

　　}

　　}

　　public static GlobalConfig getInstance() {

　　if (instance==null) {

　　syncInit();

　　}

　　return instance;

　　}

　　public synchronized void update(String p_data) {

　　syncUpdateIn();

　　//Update properties

　　}

　　private synchronized void syncUpdateIn() {

　　while (readCount > 0) {

　　try {

　　wait();

　　} catch (Exception e) {

　　}

　　}

　　}

　　private synchronized void syncReadIn() {

　　readCount++;

　　}

　　private synchronized void syncReadOut() {

　　readCount--;

　　notifyAll();

　　}

　　public Vector getProperties() {

　　syncReadIn();

　　//Process data

　　syncReadOut();

　　return properties;

　　}

　　}

　　public class GlobalConfig {

　　private static GlobalConfig instance;

　　private Vector properties = null;

　　private boolean isUpdating = false;

　　private int readCount = 0;

　　private GlobalConfig() {

　　//Load configuration information from DB or file

　　//Set values for properties

　　}

　　private static synchronized void syncInit() {

　　if (instance == null) {

　　instance = new GlobalConfig();

　　}

　　}

　　public static GlobalConfig getInstance() {

　　if (instance==null) {

　　syncInit();

　　}

　　return instance;

　　}

　　public synchronized void update(String p_data) {

　　syncUpdateIn();

　　//Update properties

　　}

　　private synchronized void syncUpdateIn() {

　　while (readCount > 0) {

　　try {

　　wait();

　　} catch (Exception e) {

　　}

　　}

　　}

　　private synchronized void syncReadIn() {

　　readCount++;

　　}

　　private synchronized void syncReadOut() {

　　readCount--;

　　notifyAll();

　　}

　　public Vector getProperties() {

　　syncReadIn();

　　//Process data

　　syncReadOut();

　　return properties;

　　}

　　}

　　四，单体模式的不同表现形式

　　不同表现形式

　　1，饿汉式单体类：类被加载的时候将自己初始化。更加安全些。

　　2 ，懒汉式单体类：在第一次被引用的时候将自己初始化。提高了效率。

　　3，多例类(多例模式):除了可以提供多个实例，其他和单体类没有区别。

　　所谓多例（Multiton Pattern）实际上就是单例模式的自然推广。作为对象的创建模式，多例模式或多例类有以下的特点

　　a、多例类可以有多个实例

　　b、多例类必须自己创建，管理自己的实例，并向外界提供自己的实例。 这种允许有限个或无限个实例，并向整个JVM提供自己实例的类叫做多例类，这种模式叫做多例模式

　　1，有上限多例模式 有上限的多例类已经吧实例的上限当作逻辑的一部分，并建造到了多例类的内部，这种多例模式叫做有上限多例模式。

　　view plaincopy to clipboardprint?

　　import java.util.Date;

　　public class Die

　　{

　　private static Die die1 = new Die();

　　private static Die die2 = new Die();

　　/**

　　*私有的构造函数保证外界无法直接将此类实例化

　　*

　　*/

　　private Die()

　　{

　　}

　　/**

　　*工厂方法

　　*/||| 　　public static Die getInstance(int whichOne)

　　{

　　if(whichOne==1)

　　{

　　return die1;

　　}else{

　　return die2;

　　}

　　}

　　/**

　　*投骰子，返回一个在1－6之间的随机数

　　*/

　　public synchronized int dice()

　　{

　　Date d = new Date();

　　Random r = new Random(d.getTime());

　　int value = r.nextInt();//获取随机数

　　value = Math.abs(value);//获取随机数的绝对值

　　value = value % 6;//对6取模

　　value +=1;//由于 value的范围是0－5，所以value+1成为1-6

　　return value;

　　}

　　}

　　/**

　　*测试的客户端，投掷骰子

　　*/

　　public class DieClient

　　{

　　private static Die die1,die2;

　　public static void main(String args)

　　{

　　die1 = Die.getInstance(1);

　　die2 = Die.getInstance(2);

　　System.out.println(die1.dice());

　　System.out.println(die2.dice());

　　}

　　}

　　import java.util.Random;

　　import java.util.Date;

　　public class Die

　　{

　　private static Die die1 = new Die();

　　private static Die die2 = new Die();

　　/**

　　*私有的构造函数保证外界无法直接将此类实例化

　　*

　　*/

　　private Die()

　　{

　　}

　　/**

　　*工厂方法

　　*/

　　public static Die getInstance(int whichOne)

　　{

　　if(whichOne==1)

　　{

　　return die1;

　　}else{

　　return die2;

　　}

　　}

　　/**

　　*投骰子，返回一个在1－6之间的随机数

　　*/

　　public synchronized int dice()

　　{

　　Date d = new Date();

　　Random r = new Random(d.getTime());

　　int value = r.nextInt();//获取随机数

　　value = Math.abs(value);//获取随机数的绝对值

　　value = value % 6;//对6取模

　　value +=1;//由于 value的范围是0－5，所以value+1成为1-6

　　return value;

　　}

　　}

　　/**

　　*测试的客户端，投掷骰子

　　*/

　　public class DieClient

　　{

　　private static Die die1,die2;

　　public static void main(String args)

　　{

　　die1 = Die.getInstance(1);

　　die2 = Die.getInstance(2);

　　System.out.println(die1.dice());

　　System.out.println(die2.dice());

　　}

　　}2，无上限多例模式 实例数目没有上限的多例模式叫无上限多例模式。 注意：由于没有上限的多例类对实例的数目是没有限制的，因此，虽然这种多例模式是单例模式的推广，但是这种多例类并不一定能够回到单例类。 由于事先不知道要创建多少个实例，因此，必然使用聚集管理所有的实例。

　　view plaincopy to clipboardprint?

　　import java.util.ArrayList;

　　import java.util.HashMap;

　　public class ShoppingCart {

　　//private ShoppingCart shoppingCart = null;

　　//使用HashMap聚集管理所有的实例；

　　private static HashMap instanse = new HashMap();

　　//订单列表

　　private ArrayList orderedItems = null;

　　//更新器

　　private int readCount = 0;

　　/**

　　*同单例类一样，私有的构造函数保证外界无法直接将此类实例化

　　*

　　*/

　　private ShoppingCart() {

　　orderedItems = new ArrayList();

　　}

　　/*

　　* 获取购物车，一个用户只能有一个购物车。有多少用户就有多少购物车。

　　* */

　　public synchronized static ShoppingCart getInstance(String user) {

　　ShoppingCart shoppingCart = instanse.get(user);

　　if (shoppingCart == null){

　　shoppingCart = new ShoppingCart();

　　instanse.put(user, shoppingCart);