java 单态模式

核心--在类的内部把构造器私有化,同时在内部产生对象,并通过类.静态方法(static)返回实例化对象的引用

设计模式是在大量的实践总结和理论化之后优选的代码结果,编程风格,以及解决问题的思考方式.设计模式就像是经典的棋谱,不同的棋局我们用不同的棋谱.

单态设计模式：采取一定的方法保证在整个软件系统中,对某个类只能产生一个对象实例,并且该类只提供一个取得其对象的实例方法.

在java中实现单态模式只需要执行以下三步：  

  1.将类的构造方法的访问权限声明为private.这样就不能用new操作符在类的外部产生类的对象了,但在类内部仍可以产生该类的对象.

  2.在类内部生成一个静态的实例.

  3.提供一个静态的方法用于外部取得该类的实例.

  因为在类的外部无法得到类的对象,所以只能调用该类的某个静态方法以返回类内部创建的对象,又因为静态方法只能访问类中的静态成员变量,所以,指向类内部产生该类对象的变量也必须定义成静态的.

 

class Chinese{

    static Chinese objRef = new Chinese();

   

    private Chinese(){}

    public static Chinese getInstance(){

        return objRef;

    }

}

 

class Chinese_opt{

    static Chinese_opt objRef = null;

    private Chinese_opt(){}

    public static Chinese_opt getInstance(){

        if(objRef == null)

            objRef = new Chinese_opt();

        return objRef;

    }

   

}

class TestChinese{

    public static void main(String[] args){

        Chinese chinese1 = Chinese.getInstance();

        Chinese chinese2 = Chinese.getInstance();

        System.out.println(chinese1 == chinese2);

    }

}

 

1：构造方法私有化：

面向对象编程的三大特性：封装、继承、多态。类的封装性不仅体现在对属性的封装上，实际上方法也是可以被封装的，构造方法是特殊的方法当然也可以被封装，例如下面的代码就是对构造方法的封装：

package com.zxf.javaopp;

 

public class Singleton {

    private Singleton(){     // 将构造方法进行了封装，私有化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

构造函数被私有化，不能在外部实例化，就无法在外部使用，此时只能在该类的内部实例化对象了，然后将该类拿到外部进行使用，由于该类不能再外部实例化，此时在内部的实例化必须是用static关键字修饰的：代码如下：

package com.zxf.javaopp;

 

class Singleton1{

    static Singleton1 instance = new Singleton1() ;  // 在内部产生本类的实例化对象

    private Singleton1(){       // 将构造方法进行了封装，私有化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

public class SingletonDemo01{

    public static void main(String args[]){

       Singleton1 s1 = null ;   // 声明对象

       s1 = Singleton1.instance ;  // 取得实例化对象

       s1.print() ;      // 调用方法

    }

}

虽然上面的代码实现了功能，但又有些问题：通常情况下：我们将属性封装，此时的代码就要修改如下：

package com.zxf.javaopp;

 

class Singleton1{

    static Singleton1 instance = new Singleton1() ;  // 在内部产生本类的实例化对象

    public static Singleton1 getInstance(){       // 通过静态方法取得instance对象

       return instance ;

    }

    private Singleton1(){       // 将构造方法进行了封装，私有化  

    }

    public void print(){

       System.out.println("Hello World!!!") ;

    }

}

public class SingletonDemo01{

    public static void main(String args[]){

       Singleton1 s1 = null ;   // 声明对象

       s1 = Singleton1.getInstance() ; // 取得实例化对象

       s1.print() ;      // 调用方法

    }

}

以上的代码似乎变得很复杂，不如不将构造方法实例化呢，但是为什么又会这样做呢？

假如我们现在要产生几个对象：按以往的代码，就需要实例化多次，每个对象都有其对应的堆栈空间，此时的内存就消耗的很多，系统的效率坑定比较低，但是使用将构造方法封装的模式效率就比较高：

 使用将构造方法封装的方法：无论产生多少个对象，我们只实例化一次，这样的设计在设计模式上称为单态设计模式（单例设计模式）：

singleton , 如果不希望一个类产生多个实例的话，则必须使用单态设计模式，此设计模式，在以后的高性能开发中经常使用，而且在 java 的类库中大量的使用了此设计模式。

    所谓单态就是在入口处限制了对象的实例操作。

    单态设计模式的意义：

实际上这种模式非常常用，我们大家使用的windows操作系统中就使用了此设计模式，windows中用一个回车站： ，除了桌面以外，其他的每个硬盘中都有一个回车站，其他的回车站和其他硬盘的每个回车站都是同一个，也就是所整个操作系统中有且只有一个回车站，各个地方只是引用此实例。

总结：

单态设计模式的核心就是将类的

 构造函数私有化，在类的内部产生实例对象，并通过类的静态方法返回类的实例对象。

============================================================================================

 单例设计模式

Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。

核心知识点如下：

(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

(3) 定义一个静态方法返回该类的实例。

/** 
 * 方法一
 * 单例模式的实现：饿汉式,线程安全 但效率比较低 
 */  
public class SingletonTest {  

    // 定义一个私有的构造方法
    private SingletonTest() {  
    }  

    // 将自身的实例对象设置为一个属性,并加上Static和final修饰符
    private static final SingletonTest instance = new SingletonTest();  

    // 静态方法返回该类的实例
    public static SingletonTest getInstancei() {  
        return instance;  
    }  
  
}

方法一就是传说的中的饿汉模式
优点是：写起来比较简单，而且不存在多线程同步问题，避免了synchronized所造成的性能问题；
缺点是：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

/**  
 *方法二
 * 单例模式的实现：饱汉式,非线程安全   
 *   
 */  
public class SingletonTest {

    // 定义私有构造方法（防止通过 new SingletonTest()去实例化）
    private SingletonTest() {   
    }   

    // 定义一个SingletonTest类型的变量（不初始化，注意这里没有使用final关键字）
    private static SingletonTest instance;   

    // 定义一个静态的方法（调用时再初始化SingletonTest，但是多线程访问时，可能造成重复初始化问题）
    public static SingletonTest getInstance() {   
        if (instance == null)   
            instance = new SingletonTest();   
        return instance;   
    }   
} 

方法二就是传说的中的饱汉模式
优点是：写起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间，当getInstance方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存；
缺点是：并发环境下很可能出现多个SingletonTest实例。

/**  
 *方法三
 * 单例模式的实现：饱汉式,线程安全简单实现   
 *   
 */  
public class SingletonTest {

    // 定义私有构造方法（防止通过 new SingletonTest()去实例化）
    private SingletonTest() {   
    }   

    // 定义一个SingletonTest类型的变量（不初始化，注意这里没有使用final关键字）
    private static SingletonTest instance;   

    // 定义一个静态的方法（调用时再初始化SingletonTest，使用synchronized 避免多线程访问时，可能造成重的复初始化问题）
    public static synchronized  SingletonTest getInstance() {   
        if (instance == null)   
            instance = new SingletonTest();   
        return instance;   
    }   
} 

方法三为方法二的简单优化
优点是：使用synchronized关键字避免多线程访问时，出现多个SingletonTest实例。
缺点是：同步方法频繁调用时，效率略低。

/**  
 * 方法四
 * 单例模式最优方案
 * 线程安全  并且效率高  
 *  
 */  
public class SingletonTest { 

    // 定义一个私有构造方法
    private SingletonTest() { 
     
    }   
    //定义一个静态私有变量(不初始化，不使用final关键字，使用volatile保证了多线程访问时instance变量的可见性，避免了instance初始化时其他变量属性还没赋值完时，被另外线程调用)
    private static volatile SingletonTest instance;  

    //定义一个共有的静态方法，返回该类型实例
    public static SingletonTest getIstance() { 
        // 对象实例化时与否判断（不使用同步代码块，instance不等于null时，直接返回对象，提高运行效率）
        if (instance == null) {
            //同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建）
            synchronized (SingletonTest.class) {
                //未初始化，则初始instance变量
                if (instance == null) {
                    instance = new SingletonTest();   
                }   
            }   
        }   
        return instance;   
    }   
}

方法四为单例模式的最佳实现。内存占用地，效率高，线程安全，多线程操作原子性。

 

（事实上，可以通过Java反射机制来实例化private类型的构造方法，此时基本上会使所有的Java单例实现失效。本帖不讨论反射情况下问题，默认无反射，也是常见的面试已经应用场景）