设计模式相关文章
----单例模式原理-JAVA设计模式
----工厂模式原理-JAVA设计模式
代理模式原理-JAVA设计模式
----建造者模式(Bulider模式)详解—JAVA设计模式
单例模式介绍
- 说明
实现1个类只有1个实例化对象 & 提供一个全局访问点
- 作用
保证1个类只有1个对象,降低对象之间的耦合度
使用场景
- 网站的计数器,一般也是采用单例模式实现,否则难以同步。
- 应用程序的日志应用,一般都是单例模式实现,只有一个实例去操作才好,否则内容不好追加显示。
- 多线程的线程池的设计一般也是采用单例模式,因为线程池要方便对池中的线程进行控制
- Windows的(任务管理器)就是很典型的单例模式,他不能打开俩个
- windows的(回收站)也是典型的单例应用。在整个系统运行过程中,回收站只维护一个实例
单例模式实现方式
- 单例模式的实现方式有多种,根据需求场景,可分为2大类、6种实现方式。具体如下
实现方式:
- 饿汉式
- 枚举类型
- 懒汉式
- 同步锁(懒汉式的改进)
- 双重校验锁(懒汉式的改进)
- 静态内部类
1、饿汉式
- 原理
依赖 JVM类加载机制,保证单例只会被创建1次,类初始化时,会立即加载该对象,即线程安全,调用效率高 - JVM在类的初始化阶段(即 在Class被加载后、被线程使用前),会执行类的初始化
- 在执行类的初始化期间,JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化
- 代码实现
/**
* Created with IntelliJ IDEA.
*
* @Auther: curry
* @Description:
*/
public class Singleton {
// 1. 加载该类时,单例就会自动被创建
private static Singleton ourInstance = new Singleton();
// 2. 构造函数 设置为 私有权限
// 原因:禁止他人创建实例
private Singleton() {
System.out.println("私有构造参数初始化");
}
// 3. 通过调用静态方法获得创建的单例
public static Singleton newInstance() {
return ourInstance;
}
//测试调用
public static void main(String[] args) {
Singleton s1 = Singleton.newInstance();
Singleton s2 = Singleton .newInstance();
System.out.println("结果:");
System.out.println(s1 == s2);
}
}
- 运行结果
私有构造参数初始化
结果:
true
- 应用场景
除了初始化单例类时 即 创建单例外,继续延伸出来的是:单例对象 要求初始化速度快 & 占用内存小
2、枚举类型
-
原理
满足单例模式所需的 创建单例、线程安全、实现简洁的需求 -
代码实现
public class Singleton {
public static Singleton getInstance() {
return Demo.INSTANCE.getInstance();
}
//定义枚举
private static enum Demo {
INSTANCE;
// 枚举元素为单例
private Singleton singleton;
private Demo() {
System.out.println("枚举Demo私有构造参数");
singleton = new Singleton();
}
public Singleton getInstance() {
return singleton;
}
}
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}
- 运行结果
枚举Demo私有构造参数
true
单元素的枚举类型已经成为实现 Singleton的最佳方法
3、懒汉式(基础实现)
- 原理
单例创建时机可控,即有需要时,才 手动创建 单例 - 代码实现
public class Singleton {
// 1. 类加载时,先不自动创建单例,将单例的引用先赋值为 Null
private static Singleton ourInstance = null;
// 2. 构造函数 设置为 私有权限
// 原因:禁止他人创建实例
private Singleton() {
System.out.println("私有构造参数初始化");
}
// 3. 需要时才手动调用 newInstance() 创建 单例
public static Singleton newInstance() {
// 先判断单例是否为空,以避免重复创建
if( ourInstance == null){
ourInstance = new Singleton();
}
return ourInstance;
}
//测试调用
public static void main(String[] args) {
Singleton s1 = Singleton.newInstance();
Singleton s2 = Singleton .newInstance();
System.out.println("懒汉式基础实现,结果:");
System.out.println(s1 == s2);
}
}
- 运行结果
私有构造参数初始化
懒汉式基础实现,结果:
true
基础实现的懒汉式是线程不安全的
4、同步锁(懒汉式的改进)
- 原理
使用同步锁synchronized
锁住创建单例的方法 ,防止多个线程同时调用,从而避免造成单例被多次创建 - 代码实现
// 写法1
class Singleton {
// 1. 类加载时,先不自动创建单例
// 即,将单例的引用先赋值为 Null
private static Singleton ourInstance = null;
// 2. 构造函数 设置为 私有权限
// 原因:禁止他人创建实例
private Singleton() {
}
// 3. 加入同步锁
public static synchronized Singleton getInstance(){
// 先判断单例是否为空,以避免重复创建
if ( ourInstance == null )
ourInstance = new Singleton();
return ourInstance;
}
}
// 写法2
// 该写法的作用与上述写法作用相同,只是写法有所区别
class Singleton{
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance(){
// 加入同步锁
synchronized(Singleton.class) {
if (instance == null)
instance = new Singleton();
}
return instance;
}
}
//测试调用
public static void main(String[] args) {
Singleton s1 = Singleton.newInstance();
Singleton s2 = Singleton .newInstance();
System.out.println("懒汉式的改进,结果:");
System.out.println(s1 == s2);
}
- 运行结果
私有构造参数初始化
懒汉式的改进,结果:
true
- 缺点
每次访问都要进行线程同步(即 调用synchronized锁),造成过多的同步开销(加锁 = 耗时、耗能)
5、双重校验锁(懒汉式的改进)
双重检测锁方式 (因为JVM本质重排序的原因,可能会初始化多次,不推荐使用)
- 原理
在同步锁的基础上,添加1层 if判断:若单例已创建,则不需再执行加锁操作就可获取实例,从而提高性能 - 代码实现
public class Singleton {
private static Singleton ourInstance = null;
private Singleton() {
System.out.println("私有构造参数初始化");
}
public static Singleton newInstance() {
// 加入双重校验锁
// 校验锁1:第1个if
if( ourInstance == null){ // ①
synchronized (Singleton.class){ // ②
// 校验锁2:第2个 if
if( ourInstance == null){
ourInstance = new Singleton();
}
}
}
return ourInstance;
}
public static void main(String[] args) {
Singleton s1 = Singleton.newInstance();
Singleton s2 = Singleton.newInstance();
System.out.println("懒汉式双重校验锁,结果:");
System.out.println(s1 == s2);
}
}
// 说明
// 校验锁1:第1个if
// 作用:若单例已创建,则直接返回已创建的单例,无需再执行加锁操作
// 即直接跳到执行 return ourInstance
// 校验锁2:第2个 if
// 作用:防止多次创建单例问题
// 原理
// 1. 线程A调用newInstance(),当运行到②位置时,此时线程B也调用了newInstance()
// 2. 因线程A并没有执行instance = new Singleton();,此时instance仍为空,因此线程B能突破第1层 if 判断,运行到①位置等待synchronized中的A线程执行完毕
// 3. 当线程A释放同步锁时,单例已创建,即instance已非空
// 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空(单例已创建),因此也不会创建多余的实例
- 运行结果
私有构造参数初始化
懒汉式双重校验锁,结果:
true
- 缺点
实现复杂 = 多种判断,易出错
6、静态内部类
静态内部方式:结合了懒汉式和饿汉式各自的优点,真正需要对象的时候才会加载,加载类是线程安全的
- 原理
在静态内部类里创建单例,在装载该内部类时才会去创建单例,线程安全:类是由 JVM加载,而JVM只会加载1遍,保证只有1个单例 - 代码实现
public class Singleton {
// 1. 创建静态内部类
private static class Singleton2 {
// 在静态内部类里创建单例
private static Singleton ourInstance = new Singleton();
}
// 私有构造函数
private Singleton() {
}
// 延迟加载、按需创建
public static Singleton newInstance() {
return Singleton2.ourInstance;
}
//测试调用
public static void main(String[] args) {
Singleton s1 = Singleton.newInstance();
Singleton s2 = Singleton .newInstance();
System.out.println("静态内部类,结果:");
System.out.println(s1 == s2);
}
}
// 调用过程说明:
// 1. 外部调用类的newInstance()
// 2. 自动调用Singleton2.ourInstance
// 2.1 此时单例类Singleton2得到初始化
// 2.2 而该类在装载 & 被初始化时,会初始化它的静态域,从而创建单例;
// 2.3 由于是静态域,因此只会JVM只会加载1遍,Java虚拟机保证了线程安全性
// 3. 最终只创建1个单例
- 运行结果
静态内部类,结果:
true
设计模式相关文章
----单例模式原理-JAVA设计模式
----工厂模式原理-JAVA设计模式
代理模式原理-JAVA设计模式
----建造者模式(Bulider模式)详解—JAVA设计模式