单例设计模式就是要保证单个类的对象在内存中的唯一性。外部不能new单例设计的 类对象，所以必须私有其构造方法。
- 保证唯一性，构造方法只能私有
- 构造私有，外部无法建立对象，所以只能内部new对象
- 为了拿到对象，接着只能建立静态方法（外部没有办法new对象，所以只能类名调用静态方法），返回内部对象
- 又因为静态不能访问非静态，所以内部对象也只能是静态的
单例设计模式也叫饿汉，除此之外还有一种叫懒汉（内部对象的延迟加载，线程不安全），详情见代码
demo：
package single;
/*
* 单利设计模式，保证对象在内存中的唯一性
*
* 1.保证唯一性，构造方法只能私有
* 2.构造私有，外部无法建立对象
* 3.只能内部new对象出来
* 4.为了拿到对象，接着只能建立静态方法，返回内部对象
* 5.静态不能访问非静态，所以内部对象也只能是静态的
*
* 懒汉式线程不安全
*
* java内的Runtime也是单例设计模式
*/
public class SingleTest {
public static void main(String[] args) {
/*
* 单例（饿汉式）
*/
//外部无论如何获取，都只能拿到一个对象
Single s = Single.getInstance();
System.out.println(s);
Single s1 = Single.getInstance();
System.out.println(s1);
/*
* 单例（懒汉式）
*/
SingleL sL = SingleL.getInstance();
System.out.println(sL);
SingleL sL1 = SingleL.getInstance();
System.out.println(sL1);
}
}
//单例类（饿汉式）
class Single{
private static Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}
//单例类（懒汉式） 延迟加载 ，线程不安全
class SingleL{
private static SingleL s = null;
private SingleL(){}
public static SingleL getInstance(){
if(s == null)
s = new SingleL();
return s;
}
}
java内也有单例设计模式的类对象：Runtime类，源码如下（JAVA 1.8)
public class Runtime {
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
...
}
上文提到了懒汉模式（延迟加载）是有线程安全问题的。下面就解释为什么在多线程下会出现不安全的情况，怎么来解决这个问题。
原因：
出现不安全的因素其实很简单，因为多线程下会并发的访问getInstance方法，有可能一个进程执行到if(s == null)这个逻辑代码块中，此时线程跳走了，但是对象还没new出来。，另一个进程又加载运行了此方法。接着原来的那个进程执行完剩下的代码。这样就new了两次对象，导致出现了多个单例对象的实例，产生了不安全的因素。
那如何来解决呢，具体方法请看下面的示例代码。
code:
package thread;
/*
* 懒汉的多线程安全问题解决
*/
public class ThreadDemo3 {
public static void main(String[] args) {
// 建立多线程，来运行
SingleThread s = new SingleThread();
/*
* 结果出现了两个懒汉的实例
*
* thread.Single2@6b2ce86d
* thread.Single2@719e4b38
*
* 解决办法： 将getInstace的方法变为同步方法，或者加同步代码块
*/
new Thread(s).start();
new Thread(s).start();
}
}
// 来一个懒汉类
class Single2 {
private static Single2 s = null;
private Single2() {
}
public static Single2 getInstance() {
// 静态方法，锁上class
// 双重if，避免不必要的进入同步代码块,提高效率
if (s == null) {
synchronized (Single2.class) {
if (s == null)
s = new Single2();
}
}
return s;
}
}
// 来一个Runnable的子类来玩懒汉
class SingleThread implements Runnable {
public void run() {
for (int i = 0; i < 20; i++) {
Single2 s2 = Single2.getInstance();
System.out.println(s2);
}
}
}
