一、单例模式介绍：
1.概述：
Singleton（单例）是一种创建型模式，指某个类如果采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点。
2.设计要点：
(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。
(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。
(3) 定义一个静态方法返回该类的实例。
3.单例模式的好处：
单例模式也是一种比较常见的设计模式，它到底能带给我们什么好处呢？其实无非是三个方面的作用：
1、控制资源的使用，通过线程同步来控制资源的并发访问；
2、控制实例产生的数量，达到节约资源的目的。
3、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。
二、单例模式分类及示例：
1.简单的饿汉模式：声明对象时就创建对象
（1）SingleTonFirst.java
package singleton.first;
/**
* 方法一
* 单例模式的实现：饿汉式,线程安全 但效率比较低
*/
public class SingleTonFirst {
//定义并创建实例变量，类加载的时候就会创建对象
private static SingleTonFirst instance= new SingleTonFirst();
//定义私有的构造函数，确保实例对象只能在该类中创建
private SingleTonFirst(){
}
//提供一个共有的，静态的方法供其它类获取该类的实例对象
public static SingleTonFirst getSingleTon(){
return instance;
}
public void otherMethod(){
//该方法代表其它需要真正进行逻辑处理的方法
System.out.println("你好，单例对象已经获取完成，单例对象正在调用自己的方法进行逻辑处理！");
}
}（2）测试类：TestFirst.java
package singleton.first;
import org.junit.Test;
public class TestFirst {
@Test
public void Test(){
SingleTonFirst instance = SingleTonFirst.getSingleTon();
instance.otherMethod();
}
}（3）分析：
优点是：写起来比较简单，而且不存在多线程同步问题，避免了synchronized所造成的性能问题。
缺点是：当类SingletonTest被加载的时候，会初始化static的instance，静态变量被创建并分配内存空间，从这以后，这个static的instance对象便一直占着这段内存（即便你还没有用到这个实例），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。
2.简单的饱汉模式：第一次方法调用时创建对象
（1）SingleTonSecond.java
package singleton.second;
/**
* 方法二
* 单例模式的实现：饱汉式,非线程安全
*
*/
public class SingleTonSecond {
//定义并实例变量，第一次方法调用时实例化
private static SingleTonSecond instance;
//定义私有的构造函数，确保实例对象只能在该类中创建
private SingleTonSecond(){
}
//提供一个共有的，静态的方法供其它类获取该类的实例对象
public static SingleTonSecond getSingleTonSecond(){
if (instance == null)
instance = new SingleTonSecond();
return instance;
}
public void otherMethod(){
//该方法代表其它需要真正进行逻辑处理的方法
System.out.println("你好，单例对象已经获取完成，单例对象正在调用自己的方法进行逻辑处理！");
}
}（2）测试类：TestSecond.java
package singleton.second;
import org.junit.Test;
public class TestSecond {
@Test
public void test(){
SingleTonSecond instance = SingleTonSecond.getSingleTonSecond();
instance.otherMethod();
}
}（3）分析：
优点是：写起来比较简单，当类SingletonTest被加载的时候，静态变量static的instance未被创建并分配内存空间，当getSingleTonSecond()方法第一次被调用时，初始化instance变量，并分配内存，因此在某些特定条件下会节约了内存；
缺点是：并发环境下很可能出现多个SingletonTest实例。
3.线程安全的饱汉模式：创建对象的方法加上synchronized关键字
（1）SingleTonThird.java
package singleotn.third;
/**
* 方法三
* 单例模式的实现：饱汉式,线程安全简单实现
*
*/
public class SingleTonThird {
private static SingleTonThird instance;
// 定义私有构造方法（防止其它类通过 new SingletonTest()去实例化）
private SingleTonThird(){
}
// 定义一个静态的方法（调用时再初始化SingleTonThird，使用synchronized 避免多线程访问时，可能造成重的复初始化问题
public static synchronized SingleTonThird getSingleTonThird(){
if(instance==null){
instance = new SingleTonThird();
}
return instance;
}
//该方法代表其它需要真正进行逻辑处理的方法
public void otherMethod(){
System.out.println("你好，单例对象已经获取完成，单例对象正在调用自己的方法进行逻辑处理！");
}
}（2）测试类：TestThird.java
package singleotn.third;
import org.junit.Test;
public class TestThird {
@Test
public void test(){
SingleTonThird instance = SingleTonThird.getSingleTonThird();
instance.otherMethod();
}
}（3）分析：
优点是：使synchronized关键字避免多线程访问时，出现多个SingletonTest实例。
缺点是：同步方法频繁调用时，效率略低。
4.最优单例模式：线程安全且效率高
（1）SingleTonFourth.java
package singleton.fourth;
/**
* 方法四
* 单例模式最优方案
* 线程安全 并且效率高
*
*/
public class SingleTonFourth {
//定义静态的实例变量，用volatile修饰表示对象修改后其它线程是可见的
private static volatile SingleTonFourth instance;
// 定义一个私有构造方法,防止其他类中通过new关键字创建对象
private SingleTonFourth(){
}
//定义静态方法供其他类创建此类的对象
public static SingleTonFourth getSingleTonFourth(){
if(instance==null){
//同步代码块（对象未初始化时，使用同步代码块，保证多线程访问时对象在第一次创建后，不再重复被创建
synchronized (SingleTonFourth.class){
if(instance == null){
instance = new SingleTonFourth();
}
}
}
return instance;
}
//该方法代表其它需要真正进行逻辑处理的方法
public void otherMethod(){
System.out.println("你好，单例对象已经获取完成，单例对象正在调用自己的方法进行逻辑处理！");
}
}（2）测试类：TestFourth.java
package singleton.fourth;
import org.junit.Test;
public class TestFourth {
@Test
public void test(){
SingleTonFourth instance = SingleTonFourth.getSingleTonFourth();
instance.otherMethod();
}
}（3）分析：内存占用地，效率高，线程安全，多线程操作原子性。