zoukankan      html  css  js  c++  java

  • 单例类多线程

    作为设计模式理论中的Helloworld，相信学习java语言的人，都应该听说过单例模式。单例模式作为对象的一种创建模式，它的作用是确保某一个类在整个系统中只有一个实例，而且自行实例化并向整个系统提供这个实例。

    由此可见，单例模式具有以下的特点：

    1. 单例类只能有一个实例。
    2. 单例类必须自己创建自己的唯一的实例。
    3. 单例类必须给所有其他对象提供这一实例。

    由于Java语言的特点，使得单例模式在Java语言的实现上有自己的特点。这些特点主要表现在单例类如何将自己实例化。

    饿汉式单例类

    饿汉式单例类是在Java语言里实现起来最为简便的单例类。其源代码如下：

    01 public class EagerSingleton {
    02  
    03     /** 通过静态变量初始化的类实例 */
    04     private static final EagerSingleton instance = new EagerSingleton();
    05  
    06     /**
    07      * 私有的默认构造子
    08      */
    09     private EagerSingleton() {
    10     }
    11  
    12     /**
    13      * 获取唯一类实例的静态工厂方法
    14      *
    15      * @return
    16      */
    17     public static EagerSingleton getInstance() {
    18         return instance;
    19     }
    20  
    21 }

    由Java语言类的初始化顺序可知，在这个类被加载时，静态变量会被初始化，此时类的私有构造子会被调用。这时候，单例类的唯一实例就被创建出来了。

    Java语言中单例类的一个最重要的特点是类的构造子是私有的，从而避免外界使用构造子直接创建出任意多该类的实例。值得指出的是，由于构造子是私有的，因此该类不能被继承。

    对于私有构造，可以使用反射破解。下面这段很重要。
    if (instance != null) {
    throw new UnsupportedOperationException("不能构造！");
    }

    懒汉式单例类

    与饿汉式单例类相同之处是，懒汉式单例类的构造子也是私有的。而与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时将自己实例化。在懒汉式单例类被加载时，不会将自己实例化。其源代码如下所示：

    01 public class LazySingleton {
    02  
    03     /**
    04      * 此时静态变量不能声明为final，因为需要在工厂方法中对它进行实例化
    05      */
    06     private static LazySingleton instance;
    07  
    08     /**
    09      * 私有构造子，确保无法在类外实例化该类
    10      */
    11     private LazySingleton() {
    12     }
    13  
    14     /**
    15      * synchronized关键字解决多个线程的同步问题
    16      */
    17     public static synchronized LazySingleton getInstance() {
    18         if (instance == null) {
    19             instance = new LazySingleton();
    20         }
    21         return instance;
    22     }
    23  
    24 }

    静态工厂方法中synchronized关键字提供的同步是必须的，否则当多个线程同时访问该方法时，无法确保获得的总是同一个实例。然而我们也看到，在所有的代码路径中，虽然只有第一次引用的时候需要对instance变量进行实例化，但是synchronized同步机制要求所有的代码执行路径都必须先获取类锁。在并发访问比较低时，效果并不显著，但是当并发访问量上升时，这里有可能会成为并发访问的瓶颈。

    如果本文言尽于此，那实在没什么写的必要，因为以上介绍的知识，你可以从任何一本介绍单例模式的书查得到。下面我们来看看，为了降低线程同步的开销，从懒汉式单例模式中引申出来的两种很有意思的单例模式写法。

    延长初始化占位

    这种单例模式的写法，是著名的《Java Concurrency in Practice》一书中介绍对象的安全发布时介绍的。我们先来看它的源代码。

    01 public class ResourceFactory {
    02  
    03     private static class ResourceHolder {
    04         public static Resource resource = new Resource();
    05     }
    06  
    07     public static Resource getResource() {
    08         return ResourceHolder.resource;
    09     }
    10  
    11 }

    要理解上面这种单例类的写法，你需要先学习一些关于Java虚拟机如何初始化一个类的知识。

    在java虚拟机中，类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括了：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）七个阶段。其中，验证、准备和解析三个部分统称为连接（Linking）。

    加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也被称为动态绑定或晚期绑定）。

    什么情况下需要开始类加载的第一个阶段：加载。虚拟机规范中并没有进行强制约束，这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范则是严格规定了有且只有四种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

    1）遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这四条字节码指令最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。

    2）使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。

    3）当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。

    4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main（）方法的那个类），虚拟机会先初始化这个主类。

    这四种场景中的行为称为对一个类进行主动引用，除此之外所有引用类的方式，都不会触发类的初始化，被称为被动引用。以下是三个例子：

    1）通过子类引用父类的静态字段，不会导致子类初始化。

    2）通过数组定义来引用类，不会触发此类的初始化。

    3）常量在编译阶段会存入调用类的常量池，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

    （以上摘自《深入理解Java虚拟机》）

    从上面介绍的知识可以知道，JVM将推迟ResourceHolder类的初始化，直到第一个代码访问路径调用getResource()方法。此时，由于ResourceHolder.resource是一个读取静态字段的主动引用，虚拟机将第一次加载ResourceHolder类，并且通过一个静态变量来初始化Resource实例。而其他访问getResource()方法的代码路径，并不需要同步。

    不需要额外的同步，但是又能确保对象可见性的正确发布，这是由Java的虚拟机规范所决定的！上面这种单例模式的写法，体现出对虚拟机规范的深刻理解，实在是专家级别的写法。

    用读写锁编写的单例模式

    在阅读Struts2源码的时候，我发现一个有意思的单例类写法：LoggerFactory。这里和大家分享一下，先看一下源码。

    01 package com.opensymphony.xwork2.util.logging;
    02  
    03 import com.opensymphony.xwork2.util.logging.jdk.JdkLoggerFactory;
    04  
    05 import java.util.concurrent.locks.ReadWriteLock;
    06 import java.util.concurrent.locks.ReentrantReadWriteLock;
    07  
    08 /**
    09  * Creates loggers.  Static accessor will lazily try to decide on the best factory if none specified.
    10  */
    11 public abstract class LoggerFactory {
    12      
    13     private static final ReadWriteLock lock = new ReentrantReadWriteLock();
    14     private static LoggerFactory factory;
    15      
    16     public static void setLoggerFactory(LoggerFactory factory) {
    17         lock.writeLock().lock();
    18         try {
    19             LoggerFactory.factory = factory;
    20         } finally {
    21             lock.writeLock().unlock();
    22         }
    23              
    24     }
    25      
    26     public static Logger getLogger(Class<?> cls) {
    27         return getLoggerFactory().getLoggerImpl(cls);
    28     }
    29      
    30     public static Logger getLogger(String name) {
    31         return getLoggerFactory().getLoggerImpl(name);
    32     }
    33      
    34     protected static LoggerFactory getLoggerFactory() {
    35         lock.readLock().lock();
    36         try {
    37             if (factory != null) {
    38                 return factory;
    39             }
    40         } finally {
    41             lock.readLock().unlock();
    42         }
    43         lock.writeLock().lock();
    44         try {
    45             if (factory == null) {
    46                 try {
    47                     Class.forName("org.apache.commons.logging.LogFactory");
    48                     factory = new com.opensymphony.xwork2.util.logging.commons.CommonsLoggerFactory();
    49                 } catch (ClassNotFoundException ex) {
    50                     // commons logging not found, falling back to jdk logging
    51                     factory = new JdkLoggerFactory();
    52                 }
    53             }
    54             return factory;
    55         }
    56         finally {
    57             lock.writeLock().unlock();
    58         }
    59     }
    60      
    61     protected abstract Logger getLoggerImpl(Class<?> cls);
    62      
    63     protected abstract Logger getLoggerImpl(String name);
    64  
    65 }

    它是一个抽象类，来看一个具体的实现类：CommonsLoggerFactory。

    01 package com.opensymphony.xwork2.util.logging.commons;
    02  
    03 import com.opensymphony.xwork2.util.logging.Logger;
    04 import com.opensymphony.xwork2.util.logging.LoggerFactory;
    05 import org.apache.commons.logging.LogFactory;
    06  
    07 /**
    08  * Creates commons-logging-backed loggers
    09  */
    10 public class CommonsLoggerFactory extends LoggerFactory {
    11  
    12     @Override
    13     protected Logger getLoggerImpl(Class<?> cls) {
    14         return new CommonsLogger(LogFactory.getLog(cls));
    15     }
    16      
    17     @Override
    18     protected Logger getLoggerImpl(String name) {
    19         return new CommonsLogger(LogFactory.getLog(name));
    20     }
    21  
    22 }

    可以看到，在大多数的代码路径下，getLoggerFactory()方法用可重入的读锁来进行同步。只在第一次访问时，使用了可重入的写锁来进行同步，进行factory对象的初始化。因为在写锁还没释放的时候，任何读锁的获取都会被阻塞，这样就保证了所发布的factory对象的可见性。

    这里的代码，很容易就可以被改造成一个单例模式的写法。通过非阻塞的读写锁，避免了懒汉式单例类中所有代码访问路径都必须先获得类锁的弊端。
  • 相关阅读:
    UICollectionView的简单使用（一）
    天气预报接口IOS版OC:SmartWeather API中key的计算方法
    IOS下Base64加密
    IOS下DES加密
    IOS的URL中文转码
    CTE Recursion Performance
    走过而立之年的Coder
    iOS多线程编程之锁的理解
    iOS设置PCH文件
    程序员：伤不起的三十岁
  • 原文地址：https://www.cnblogs.com/isoftware/p/3757979.html
Copyright © 2011-2022 走看看