JAVA设计模式课堂整理（代码都是maven引入junit包）
pom文件：
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
<scope>test</scope>
</dependency>
</dependencies>
单例模式是确保某─个类只有一个实例，而且自行实例化并向整个系统提供这个实例,
注意:某个类只能有一个实例，类必须自行创建这个实例，以公共、统一的方式向整个系统提供这个实例。
线程安全，调用时间效率较高，不支持延迟加载
Java类：
package org.tawil.demo.singleton_pattern.hungry;
//1/本类一旦初始化（静态属性随类初始化赋初值)，对象即被创建，是立即加载（饿汉式)
public class HungrySingleton{
public static void fn(){
}
//2.定义一个私有的本类型的静态属性,并直接创建本类对象赋值，而且仅能在类的初始化时赋值一次
private static HungrySingleton instance = new HungrySingleton () ;
//3.提供公有的静态的获取对象实例的方法
public static HungrySingleton getInstance () {
return instance;
}
//1.构造方法私有化
private HungrySingleton(){
System.out.println("hungrysingleton is be ready");
}
}
测试类
import org.junit.Test;
import org.tawil.demo.singleton_pattern.hungry.HungrySingleton;
public class singleton_patternTest {
//测试饥汉式
@Test
public void hungryTest(){
HungrySingleton.fn ( );// Hungrysingleton第一次被使用
System.out.println( "-----------------------------------") ;
HungrySingleton instance1= HungrySingleton.getInstance() ;
HungrySingleton instance2 = HungrySingleton.getInstance() ;
System.out.println(instance1 == instance2);
}
}
线程安全（显示使用同步机制），调用时间效率较低,支持延迟加载
Java类：
package org.tawil.demo.singleton_pattern.lazy;
public class LazySingleton {
public static void fn (){}
//此处不赋初始值
private static LazySingleton instance;
public static LazySingleton getInstance() {
synchronized (LazySingleton.class) {
if (instance == null) {
//如果没有引入同步机制，当一个线程运行到这儿的时候，另一个线程可能刚好在执行if(instance == null)
// 结果两个线程都进入了本if分支
instance = new LazySingleton();
}
return instance;
}
}
private LazySingleton() {
System.out.println("lazysingleton is be ready! ");
}
}
测试类：
import org.junit.Test;
import org.tawil.demo.singleton_pattern.lazy.LazySingleton;
public class singleton_patternTest {
//测试懒汉式
@Test
public void lazyTest(){
LazySingleton.fn ( );// Hungrysingleton第一次被使用
System.out.println( "-----------------------------------") ;
LazySingleton instance1= LazySingleton.getInstance() ;
LazySingleton instance2 = LazySingleton.getInstance() ;
System.out.println(instance1 == instance2);
}
//测试懒汉式多线程
@Test
public void lazysTest() throws InterruptedException {
Thread t1 = new Thread(){
@Override
public void run(){
LazySingleton.getInstance();
}
};
Thread t2 = new Thread(){
@Override
public void run(){
LazySingleton.getInstance();
}
};
t1.start();
t2.start();
t1.join();//测试线程等待t1线程结束,再继续进行t2-join ();
t2.join();//测试线程等待t2线程结束,再继续进行
//注: junit测试线程结束时，会调用system.exit(0),导致整个系统终止
}
}
在懒汉式中：
//此处不赋初始值
private static LazySingleton instance;
public static LazySingleton getInstance() {
synchronized (LazySingleton.class) {
if (instance == null) {
//如果没有引入同步机制，当一个线程运行到这儿的时候，另一个线程可能刚好在执行if(instance == null)
// 结果两个线程都进入了本if分支
instance = new LazySingleton();
}
return instance;
}
如果interest为null，仍会进入此同步锁，等待同步锁，会降低效率
因此在这个外部再加一个检测锁：
if (instance == null) {}
此时如果interest不为null，不会进入此同步锁，不会等待同步锁，不会降低效率
instance = new DoubleCheckSingleton();执行步骤
1.在堆中分配空间（只要分配空间，引用即实际存在）
2.对象初始化
3.将对象的引用赋给变量instance
但有些编译器为提高效率会进行指令重排，将2，3颠倒。
此时：有可能某个线程被引用结果对象初始化未完成运行错误。
因此要避免指令重排
**使用volatile修饰变量**，禁止指令重排
Java类：
package org.tawil.demo.singleton_pattern.DoubleCheckSingleton;
//双检索式
public class DoubleCheckSingleton {
public static void fn (){}
//此处不赋初始值
//此处使用volatile修饰变量
private static volatile DoubleCheckSingleton instance;
public static DoubleCheckSingleton getInstance() {
if (instance == null) {//第一重检测锁锁
synchronized (DoubleCheckSingleton.class) {
if (instance == null) {//第二重检测锁
instance = new DoubleCheckSingleton();
}
}
}
return instance;
}
private DoubleCheckSingleton() {
System.out.println("DoubleCheckSingleton is be ready! ");
}
}
测试类类似懒汉式：
//测试双检锁式
@Test
public void DoubleCheckSingletonTest(){
DoubleCheckSingleton.fn ( );// Hungrysingleton第一次被使用
System.out.println( "-----------------------------------") ;
DoubleCheckSingleton instance1= DoubleCheckSingleton.getInstance() ;
DoubleCheckSingleton instance2 = DoubleCheckSingleton.getInstance() ;
System.out.println(instance1 == instance2);
}
线程安全，调用时间效率较高，支持延迟加载双重检测锁式单例模式:线程安全、调用时间效率较高，支持延迟加载
Java类
package org.tawil.demo.singleton_pattern.StaticInnerSingleton;
public class StaticInnerSingleton {
public static void fn (){}
private static class Inner{
private static StaticInnerSingleton instance = new StaticInnerSingleton();
}
public static StaticInnerSingleton getInstance(){
return Inner.instance;
}
private StaticInnerSingleton(){
System.out.println("StaticInnerSingleton is be ready!");
};
}
测试类：
//测试静态内部锁式
@Test
public void StaticInnerSingletonTest(){
StaticInnerSingleton.fn ( );// Hungrysingleton第一次被使用
System.out.println( "-----------------------------------") ;
StaticInnerSingleton instance1= StaticInnerSingleton.getInstance() ;
StaticInnerSingleton instance2 = StaticInnerSingleton.getInstance() ;
System.out.println(instance1 == instance2);
}
线程安全、调用时间效率较高，立即加载
Java类：
package org.tawil.demo.singleton_pattern.Enum;
public enum EnumSingleton {
instance;//枚举常量，天然单例，立即加载（类似饿汉式）
private EnumSingleton(){
System.out.println("枚举式单例对象创建了！");
}
public static void fn(){}
public void func(){
System.out.println("func================>");
}
}
测试类：
@Test
public void 测试枚举式单例模式(){
EnumSingleton.fn();
System.out.println("-------------------------------");
System.out.println(EnumSingleton.instance == EnumSingleton.instance);
EnumSingleton.instance.func();
}
| 单例模式 | 特点 |
|---|---|
| 饿汉式 | 线程安全，调用时间效率较高，不支持延迟加载 |
| 懒汉式 | 线程安全(显示使用同步机制)，调用时间效率较低，支持延迟加载 |
| 静态内部类 | 线程安全，调用时间效率较高，支持延迟加载 |
| 双重检测锁式 | 线程安全、调用时间效率较高，支持延迟加载 |
| 枚举式 | 线程安全、调用时间效率较高，立即加载 |