看待设计模式，要站在更大的角度（代码重用性、可读性、可扩展性、可靠性、程序高内聚，低耦合）来综合考虑看待，而不是功能实现的角度看待，不要觉得实现一个功能没必要这么麻烦
文章中给出的设计模式类图都是标准的实现方式，并不一定要完全遵守标准，所以只要设计思想符合，一个设计模式有多种实现方式，尤其是看别人源码的时候，不要用标准类图死扣
1. 单例设计模式
- 采取一定方法，保证整个软件系统运行中，只存在一个对象实例，且该类只提供一个取得其对象实例的方法
- 例如Hibernate的SessionFactory，它充当数据存储源的代理，负责创建Session对象，它不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这时就需要单例模式
- 饿汉式单例模式，如果你保证项目中必然会用到这个实例，就可以用，否则会资源浪费
- 懒汉式—双重检查版，如果项目中不一定用到这个实例，为了避免资源浪费，可以用懒汉式，但是多线程高并发场景下，需要双重检查保证线程安全
- 静态内部类实现单例，根据JVM底层运行原理实现
- 枚举类实现单例，好用，推荐
1. 饿汉式单例
- 类被加载，就实例化了实例，一直等着被使用，所以叫饿汉式
- 写法简单，类加载时就完成实例化，避免线程同步问题
- 类加载时就完成实例化，没有达到懒加载（Lazy Loading）效果，如果从始至终从未使用过这个实例，则会造成内存浪费
- 基于classloder（类加载）机制，避免了多线程同步问题，但是，instance（实例）在类加载时就实例化。在单例模式中，大多调用getInstance方法，触发类加载，但是如果有其它静态方法等一系列东西导致类加载，此时虽然我们不想使用这个单例，内存中也初始化了它。
- 这种单例模式可用，但是可能造成内存浪费
1. 静态常量版本
| 步骤：代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticConstSingleton类 |
|---|
- 构造器私有化(保证外部不可以new对象)
- 类的内部创建自己的实例对象（外部不能new，那就自己new）
- 向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)
public class StaticConstSingleton {
public static void main(String[] args) {
StaticConstSingleton singleton = StaticConstSingleton.getSingleton();
StaticConstSingleton singleton2 = StaticConstSingleton.getSingleton();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
}
private StaticConstSingleton(){
}
private static final StaticConstSingleton singleton = new StaticConstSingleton();
public static StaticConstSingleton getSingleton(){
return singleton;
}
}
2. 静态代码块版本
| 步骤：代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticCodeBlock类 |
|---|
- 构造器私有化(保证外部不可以new对象)
- 类的内部创建自己的实例对象（外部不能new，那就自己new）
- 向外暴露一个静态公共方法(外部只能通过这个方法，获取我们自己new的那一个对象)
public class StaticCodeBlock {
public static void main(String[] args) {
StaticCodeBlock singleton = StaticCodeBlock.getInstance();
StaticCodeBlock singleton2 = StaticCodeBlock.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
System.out.println("两个实例hashCode值分别是多少："+singleton2.hashCode()+"==========="+singleton.hashCode());
}
private StaticCodeBlock(){}
private static StaticCodeBlock staticCodeBlock ;
static{
staticCodeBlock = new StaticCodeBlock();
}
public static StaticCodeBlock getInstance(){
return staticCodeBlock;
}
}
2. 懒汉式
- 懒加载机制，不浪费内存，调用getInstance方法才会new实例
- 但是多线程下需要解决线程安全和同步问题
以下3种懒汉式都是多线程情况下有问题的，面试官常问，大家最好看看，了解下面3种实现方式有哪些问题，如果不想看，直接看正确的双重检查版 |
|---|
1. 线程不安全
| 步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThredUnsafetySingleton类 |
|---|
- 私有化构造函数
- 自己创静态实例，但不初始化
- 提供公共静态方法获取实例，并在这里初始化单例
| 此方法在多线程场景下，会出现如下问题，所以实际开发多线程程序不要使用这种方式 |
|---|
- 当第一个线程进入getInstace中，判断singleton为null，则创建单例
- 此时单例初始化未完成，又一个线程进入，发现singleton没有值，又进行一次初始化。出现多次初始化的问题。
- 又一个线程进入，发现有值，不为null，所以直接拿走实例
- 此时，这个线程拿了一个没有初始化完成的实例对象走了，程序出错
public class ThredUnsafetySingleton {
public static void main(String[] args) {
ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
}
private ThredUnsafetySingleton(){}
private static ThredUnsafetySingleton singleton;
public static ThredUnsafetySingleton getInstance(){
if(singleton == null){
singleton = new ThredUnsafetySingleton();
}
return singleton;
}
}
2. 线程安全，同步方法
| 步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySingleton类 |
|---|
- 在线程不安全的懒汉式版本基础上，为getInstance方法添加synchronize关键字
| 会出现如下问题，所以实际开发多线程程序不要使用这种方式 |
|---|
- 虽然解决了线程不安全问题
- 但是效率太低，每个线程想要获取类实例时，执行getInstance()方法都要进行同步，但是实例化代码只需要执行一次就够了，后面想获得该实例，直接return即可，但是现在连return都需要同步
public class ThreadSafetySingleton {
public static void main(String[] args) {
ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
}
private ThreadSafetySingleton(){}
private static ThreadSafetySingleton singleton;
public static synchronized ThreadSafetySingleton getInstance(){
if(singleton == null){
singleton = new ThreadSafetySingleton();
}
return singleton;
}
}
3. 线程安全，同步代码块
| 步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySynchroniztionCodeBlockSingleton类 |
|---|
- 在线程不安全的懒汉式版本基础上，为getInstance方法中实例化单例的代码添加synchronize关键字
| 会出现如下问题，所以实际开发多线程程序不要使用这种方式 |
|---|
- 虽然解决了效率问题，线程直接return对象时，不需要实例化单例。但是线程不安全问题重新出现了
- 当一个线程进行初始化，此时其它线程判断null进来发现代码加锁，等第一个线程走了，他还是会去执行初始化代码
- 依然会有线程拿一个默认值走的情况发生
public class ThreadSafetySynchroniztionCodeBlockSingleton {
private ThreadSafetySynchroniztionCodeBlockSingleton(){}
private static ThreadSafetySynchroniztionCodeBlockSingleton singleton;
public static ThreadSafetySynchroniztionCodeBlockSingleton getInstance(){
if(singleton == null){
synchronized (ThreadSafetySynchroniztionCodeBlockSingleton.class){
singleton = new ThreadSafetySynchroniztionCodeBlockSingleton();
}
}
return singleton;
}
}
4. 双重检查(重点)
| 步骤：代码在com.yzpnb.design_mode.singleton.idler_singleton包下DoubleCheck类 |
|---|
- 在线程安全，同步代码块的基础上，synchronized代码块中，也加上判断
- 解决线程安全问题
- 效率比直接同步方法高,只有初始化时需要同步，获取实例时，不需要同步
- 当多个线程判断实例为null，进入if执行初始化，因为初始化代码加锁，只有一个能进去
- 此时，加锁代码中，再次判断是否为null，如果是null执行初始化。第一个线程进去会执行初始化，初始化完成，释放锁，第二个线程进去再次判断，发现不为null，不执行初始化
public class DoubleCheck {
private DoubleCheck(){}
private static DoubleCheck singleton;
public static DoubleCheck getInstance(){
if(singleton == null){
synchronized (DoubleCheck.class){
if(singleton == null){
singleton = new DoubleCheck();
}
}
}
return singleton;
}
}
3. 静态内部类
- 外部类被加载时，静态内部类不会被装载
- 当我们使用静态内部类中静态变量或常量时，会加载内部类
- 类加载时，是线程安全的（JVM帮我们保证线程安全，类初始化时，其它线程无法进入）
| 基于以上3点，我们可以实现一种单例,步骤如下：代码在com.yzpnb.design_mode.singleton.inner_class_singleton包下InnerClassSingleton类 |
|---|
- 私有构造
- 静态内部类，创建实例
- 提供公共方法获取单例对象(使用静态内部类变量)
public class InnerClassSingleton {
private InnerClassSingleton(){}
private static class SingletonInstance{
private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
public static InnerClassSingleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
4. 枚举
- 借助JDK1.5中加入的枚举来实现单例模式，不仅可以避免多线程同步问题，还能防止反序列化重新创建新对象
- 是Effective Java作者Josh Bloch提倡的方式
| 步骤如下：代码在com.yzpnb.design_mode.singleton.emnu_singleton包下EmnuSingleton类 |
|---|
- 创建枚举
- 声明属性
- 用就完事了
public class EmnuSingleton {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
instance.say();
}
}
enum Singleton{
INSTANCE;
public void say(){
System.out.println("SAY---");
}
}
2、java源码中哪里用到单例？
- 我们发现只能通过getRuntime()方法获取Runtime实例对象
- 点进去看逻辑，发现就是简单的懒汉式静态常量版本
650
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
