单例模式

单例模式的定义：
Ensure a class has only one instance,and provide a gloabl point of access to it.(确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例)。

实现方法：把构造函数设置为private私有访问权限。然后只允许在本类中调用构造函数。进而达到“单例”。

优点：
1、由于单例模式在内存中只能生成一个实例，减少了内存开支，特别是一个对象需要频繁创建、销毁时，而且创建或销毁又无法优化的时候，单例模式的优势就特别明显。
2、由于单例模式只生成一个实例，所以减少了系统的性能开销，当对一个对象产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动是直接产生一个单例对象，然后永久驻留内存的方式来解决（在JAVA EE中采用单例模式时需要注意JVM垃圾回收机制）。
3、单例模式可以避免对资源的多重占用，例如一个写文件的动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时操作。
4、单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

缺点：
1、单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本么有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例、接口或抽象类是个不可能的杯实例化的。在特殊情况下，单例模式可以实现接口、被继承等，需要根据具体环境判断。
2、单例模式对测试是不利的，在并发开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象。
3、单例模式与单一职责原则有冲突，一个类应该只实现一个逻辑，而不关心他是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。

单例模式的通用代码：
（也称为饿汉模式）

public class Singleton{

private static final Singleton singleton = new Singleton();
private Singleton (){
}
public static void main(args String[]){
return singleton;
}
public static void doSomething(){
}
}

单例模式的线程不安全性：
在高并发的情况下，请注意单例模式的线程同步问题。
线程不安全的例子：

public class Singleton {

private static Singleton singleton = null;

private Singleton(){

}
public static Singleton getSingleton(){

    if(singleton == null){
        singleton = new Singleton();
    }
    return singleton;
 }

}

该单例模式在低并发的情况下尚不会出现问题，但在高并发的情况下可能在内存中出现多个实例。为什么会出现这种情况？如果一个线程A执行到singleton = new Singleton();这一步，但是尚未获得对象，而线程B获得的判断条件也是为真。于是继续运行下去，线程A和线程A都获得了一个对象，在内存中就会出现两个对象。

因此，我们可以在采取线程同步。修改如下：

public class Singleton{
    private static Singleton singleton = null;
    public static synchronized synchronized getInstance(){
         if(singleton==null){
             singleton = new Singleton();
         }
        return singleton;
    }
} 

以上代码我们称为懒汉模式

饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
推荐使用第一种
从实现方式来讲他们最大的区别就是懒汉式是延时加载,
他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建,

饿汉式无需关注多线程问题、写法简单明了、能用则用。但是它是加载类时创建实例、所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。

懒汉式的优点是延时加载、缺点是应该用同步（想改进的话现在还是不可能，比如double-check）、其实也可以不用同步、看你的需求了，多创建一两个无引用的废对象其实也没什么大不了。

单例模式的拓展：重点内容
一个类可以产生多个对象，这很容易实现，直接new就可以了，一个类只产生一个对象，我们可以采取单例模式。但是，如果我们需要两，三个对象，该怎么办了？

实现如下：

package Test;

import java.util.ArrayList;
import java.util.Random;

public class SingletonExpand {

    //最大生产对象数量
    private static int maxNum = 3;
    //用于存储对象的名字
    private static ArrayList<String> nameLists = new ArrayList<String>();
    //用于存储对象
    private static ArrayList<SingletonExpand> singletonlist = new ArrayList<SingletonExpand>();
    //当前对象序列号
    private static int countNum = 0;

    //产生所有的对象
    static{
        for(int i =0; i < maxNum ;i++){
            singletonlist.add(new SingletonExpand("对象" + i));
        }
    }
    //传入对象名，用来辅助对象的创建
    private SingletonExpand(String name){
        nameLists.add(name);

    }

    public static SingletonExpand getSingleton(){

        Random random = new Random();
        countNum = random.nextInt(maxNum);

        return singletonlist.get(countNum);
     }
    public void info(){
        System.out.println(nameLists.get(countNum));
    } 
}

client端代码：

public class client {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        for(int i=0 ; i< 5;i++){
            SingletonExpand s = SingletonExpand.getSingleton();
            System.out.println("第"+(i+1)+"次访问的对象是");
            s.info();
        }
    }

}

终端输出为：
第1次访问的对象是
对象2
第2次访问的对象是
对象1
第3次访问的对象是
对象0
第4次访问的对象是
对象2
第5次访问的对象是
对象0

通过以上代码我们便实现了一个类中有好几个（两三个）对象。