初学者第67节多线程之单例模式（十）
引言
java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 单例模式有以下特点： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其它对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。
目录
1. 饿汉式单例
2. 懒汉式单例
3. 静态嵌套类单例
4.static代码块单例
饿汉式
饿汉模式的意思就是使用该类时候就已经将该实例创建完毕了，看看饿汉式的代码
/**
* 饿汉式
*/
public class SingleTest {
/**
* 立即加载===饿汉模式
*/
private static SingleTest singleTest = new SingleTest();
private SingleTest(){}
public static SingleTest getInstance(){
return singleTest;
}
}
class Test {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
//为了演示效果这里加上延时2秒
try {
Thread.sleep(2000);
System.out.println(SingleTest.getInstance().hashCode());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
Thread thread3 = new Thread(runnable);
Thread thread4 = new Thread(runnable);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}
结果：
231187708
231187708
231187708
231187708以上使用了四个线程执行了SingleTest 类的实例。，打印出来的hashcode都是一致的表示都是同一实例。
懒汉式
懒汉式实际上就是延时加载，延时加载意思就是在调用getInstance的方法时才被创建实例。
但是懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个SingleTest 实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题。
1.改造成员变量
private static SingleTest singleTest = new SingleTest();
改为：
private static SingleTest singleTest;
2.改造getInstance方法
/**
* 饿汉式
*/
public class SingleTest {
/**
* 立即加载===饿汉模式
*/
private static SingleTest singleTest;
private SingleTest(){}
public static SingleTest getInstance() throws InterruptedException {
if (singleTest == null) {
//为了演示效果
Thread.sleep(3000);
singleTest = new SingleTest();
}
return singleTest;
}
}结果
661713944
1211537232
1834677112
231187708这样输出就出现了不同的实例，那么该怎么解决这个问题呢，这个时候就需要增加同步操作了！
继续改造getInstance方法，只需要加上同步锁关键字synchronized
public synchronized static SingleTest getInstance() throws InterruptedException {
if (singleTest == null) {
//为了演示效果
Thread.sleep(3000);
singleTest = new SingleTest();
}
return singleTest;
}
运行结果
231187708
231187708
231187708
231187708这样就实现了单例了，但是这样的效率非常低，因为每次进入该方法都需要拿到同步锁才能执行代码块，所以需要使用代码块方法来改造。
public static SingleTest getInstance() throws InterruptedException {
if (singleTest == null) {
//为了演示效果
Thread.sleep(3000);
synchronized (SingleTest.class) {
/**
* 每次进入同步块之后还需要再次判断下singleTest是否为空
* 因为在这个同步代码块的区域singleTest在线程下当第二个线程拿到锁之后
* 这个时候singleTest已经不为空了所以就不需要在实例化了这个时候就需要判断一下
* 所以需要判断一下，不过大家可以测试一下
*/
if (singleTest == null) {
singleTest = new SingleTest();
}
}
}
return singleTest;
}
运行结果：
1801285456
1801285456
1801285456
1801285456以上就是多线程下的单例模式的最常用使用方法，注释也写上去了！！！
静态嵌套类单例
直接就上代码了，单例基本上都是差不多的，只是变了一种形式展现!!!
/**
* 饿汉式
*/
public class SingleTest {
/**
* 内部嵌套类实现单例
*/
public static class MySingleTest {
/**
* 立即加载===饿汉模式
*/
private static SingleTest singleTest = new SingleTest();
}
private SingleTest(){}
public static SingleTest getInstance() throws InterruptedException {
return MySingleTest.singleTest;
}
}
class Test {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println(SingleTest.getInstance().hashCode());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
Thread thread3 = new Thread(runnable);
thread1.start();
thread2.start();
thread3.start();
}
}
结果
231187708
231187708
231187708以上就是个简单的内部嵌套类的单例模式！！！
static代码块单例模式
也很简单，看代码吧！！！
/**
* 饿汉式
*/
public class SingleTest {
/**
* 立即加载===饿汉模式
*/
private static SingleTest singleTest;
private SingleTest(){}
/**
* 代码块单例
*/
static{
singleTest = new SingleTest();
}
/**
* 获取实例的方法
* @return
*/
public static SingleTest getInstance() {
return singleTest;
}
}
class Test {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(SingleTest.getInstance().hashCode());
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
Thread thread3 = new Thread(runnable);
thread1.start();
thread2.start();
thread3.start();
}
}
运行结果：
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244
676905244好了写完了，常用的几种都写出来了，简单吧！！