Java单例模式、多例模式

//单例设计模式有两种形式：饿汉式/懒汉式
class Singleton{
//  private volatile static Singleton singleton = null;         //懒汉式
    private  static final Singleton singleton = new Singleton(); //饿汉式
    private static int count = 0;
    private Singleton(){

    }
    public static Singleton getInstrance(){
/*          懒汉式
        if(singleton == null){  
            synchronized(Singleton.class){                 
                if(singleton == null){
                    Singleton temp = new Singleton();
                    singleton = temp;
                }
            }
        }
*/
        count++;
        return singleton;
    }
    public void print(){
        System.out.println("This is Singleton ,No."+count);
    }
}

public class MainEntrance{
    public static void main(String args[]){
        Singleton singleton = Singleton.getInstrance();
        singleton.print();
        Singleton singleton2 = Singleton.getInstrance();
        singleton2.print();
    }
}

/* output
This is Singleton ,No.1
This is Singleton ,No.2
*/
程序特点： 构造函数私有化，在类的内部定义static属性与方法，
利用static关键字的特点，不管外部产生多少个Singlton，但是本质上永远只有唯一的一个实例化对象；饿汉式由于它是程序启动时就已实例化，所以在现实一般都不大采用，而更多的采用懒汉式。
下面提供另外一种简单的单例实现，即使用Java的静态内部类。

class SingletonClass{
    private static class SingletonClassInstance{
        private static final SingletonClass instance = new SingletonClass();
    }

    public static SingletonClass getInstance(){
        return SingletonClassInstance.instance;
    }

    private SingletonClass(){
        System.out.println("实例化SingletonClass");
    }
}

public class MainEntrance{  
    public static void main(String args[]){
        Thread thread = new Thread(new Runnable() {
            public void run() {
                SingletonClass.getInstance();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                SingletonClass.getInstance();
            }
        });
        thread.start();
        thread2.start();
    }
}

//output
//实例化SingletonClass
在这段代码中，因为SingletonClass没有static的属性，因此并不会被初始化。直到调用getInstance()的时候，会首先加载SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用SingletonClass的构造方法，然后getInstance()将把这个内部类的instance返回给使用者。由于这个instance是static的，因此并不会构造多次。
由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。同样，由于这个构造是并发的，所以getInstance()也并不需要加同步。所以这种方式是比较推荐的。
此方法参考“豆子空间”博客的单例模式

//多例模式
class Sex{
    private String title;
    private static Sex manSex = new Sex("Man");
    private static Sex womenSex = new Sex("Women");
    private Sex(String title){
        this.title = title;
    }
    public static Sex getInstance(int choose){
        switch (choose) {
        case Choose.MAN:
            return manSex;
        default:
            return womenSex;
        }
    }
    public String getTitle(){
        return title;
    }
}

interface Choose{
    public int MAN = 1;
    public int WOMEN = 2;
}

public class  MainEntrance{
    public static void main(String args[]){
        Sex sex = Sex.getInstance(Choose.MAN);
        System.out.println(sex.getTitle());
        Sex sex2 = Sex.getInstance(Choose.WOMEN);
        System.out.println(sex2.getTitle());
    }
}

/*output
man
women
*/
多例模式的特点跟单例模式不同的是，在类中定义了有限个可实例化的对象个数；目的是提供对此类有多个访问入口，在多线程模式下可提高异步效率。