1.应用场景：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
2.spring中的单例：Spring 中的单例模式完成了后半句话，即提供了全局的访问点 BeanFactory。但没有从构造器级别去
控制单例，这是因为 Spring 管理的是是任意的 Java 对象。 Spring 下默认的 Bean 均为单例。
3.特点：保证从系统启动到系统终止，全过程只会产生一个实例。
4.应用：当我们在应用中遇到功能性冲突的时候，需要使用单例模式
5.举例：配置文件、日历、IOC 容器
6.实现方式：
1）饿汉式 ：它是在类加载的时候就立即初始化，并且创建单例对象；
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好
缺点：类加载的时候就初始化，不管你用还是不用，我都占着空间 ，浪费了内存
绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题
public class Hungry {
private Hungry(){}
//先静态、后动态
//先属性、后方法
//先上后下
private static final Hungry hungry = new Hungry();
public static Hungry getInstance(){
// Hungry hungry;
return hungry;
}
}
2）懒汉式：
优点：在外部需要使用的时候才进行实例化，节省了空间
缺点：线程不安全。再有多线程同时访问时候会出现new出了新对象的情况
//懒汉式单例
public class LazyOne {
private LazyOne(){}
//静态块，公共内存区域
private static LazyOne lazy = null;
public static LazyOne getInstance(){
//调用方法之前，先判断
//如果没有初始化，将其进行初始化,并且赋值
//将该实例缓存好
if(lazy == null){
//两个线程都会进入这个if里面
lazy = new LazyOne();
}
//如果已经初始化，直接返回之前已经保存好的结果
return lazy;
}
}解决懒汉式线程不安全的问题：
1.方法加同步锁：效率差
public class LazyTwo {
private LazyTwo(){}
private static LazyTwo lazy = null;
public static synchronized LazyTwo getInstance(){
if(lazy == null){
lazy = new LazyTwo();
}
return lazy;
}
}
2.解决懒汉式线程不安全的最优方案：
这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题利用的知识：
1.在外部类被调用的时候内部类才会被加载,内部类一定是要在方法调用之前初始化
2.懒汉式 + 恶汉式
public class LazyThree {
private boolean initialized = false;
//默认使用LazyThree的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
private LazyThree(){
synchronized (LazyThree.class){
if(initialized == false){
initialized = !initialized;
}else{
throw new RuntimeException("单例已被侵犯");
}
}
}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写，重载
public static final LazyThree getInstance(){
//在返回结果以前，一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyThree LAZY = new LazyThree();
}
}
3）注册式：注册式是spring中最常用的单例获取方式，他使用了ConcurrentHashMap，线程安全
//Spring中的做法，就是用这种注册式单例
public class BeanFactory {
private BeanFactory(){}
//线程安全
private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
public static Object getBean(String className){
if(!ioc.containsKey(className)){
Object obj = null;
try {
obj = Class.forName(className).newInstance();
ioc.put(className,obj);
} catch (Exception e) {
e.printStackTrace();
}
return obj;
}else{
return ioc.get(className);
}
}
}4）序列化：反序列化的过程会破坏单例，生成新对象，如果希望继续使用源对象：
public class Seriable implements Serializable {
//序列化就是说把内存中的状态通过转换成字节码的形式
//从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
//内存中状态给永久保存下来了
//反序列化
//讲已经持久化的字节码内容，转换为IO流
//通过IO流的读取，进而将读取的内容转换为Java对象
//在转换过程中会重新创建对象new
public final static Seriable INSTANCE = new Seriable();
private Seriable(){}
public static Seriable getInstance(){
return INSTANCE;
}
private Object readResolve(){
return INSTANCE;
}
}重写了readResolve方法，反序列化后就会得到序列化的对象了，测试代码：
public class SeriableTest {
public static void main(String[] args) {
Seriable s1 = null;
Seriable s2 = Seriable.getInstance();
FileOutputStream fos = null;
try {
fos = new FileOutputStream("Seriable.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream("Seriable.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
s1 = (Seriable)ois.readObject();
ois.close();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1 == s2);
} catch (Exception e) {
e.printStackTrace();
}
}
}5)枚举：直接帖代码
//常量中去使用，常量不就是用来大家都能够共用吗？
//通常在通用API中使用
public enum Color {
RED(){
private int r = 255;
private int g = 0;
private int b = 0;
},BLACK(){
private int r = 0;
private int g = 0;
private int b = 0;
},WHITE(){
private int r = 255;
private int g = 255;
private int b = 255;
};
}测试类：
public class ColorTest {
public static void main(String[] args) {
System.out.println(Color.RED);
}
}以上。