單例模式

定義：是指確保一個類在任何情況下都絕對只有一個實例，并提供一個全局訪問點。

餓漢式單例模式

$\color{red}{定義：}$ 類加載的時候就立即初始化，并且創(chuàng)建單例對象，線程安全。
$\color{red}{優(yōu)點：}$ 無鎖、執(zhí)行效率比較高，在用戶體驗上來說，比懶漢式更好。
$\color{red}{缺點：}$ 類加載的時候就初始化，占用空間、內(nèi)存。
$\color{red}{適用場景：}$ 餓漢式適用在單例對象較少的情況。
$\color{red}{示例代碼：}$

/**
 * 寫法一
 */
public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}
/**
 * 餓漢式靜態(tài)塊單例
 */
class HungrySingLeton2{

    private static HungrySingLeton2 hungrySingLeton2;
    static {
        hungrySingLeton2 = new HungrySingLeton2();
    }

    private HungrySingLeton2() {}

    public HungrySingLeton2 getInstance(){
        return hungrySingLeton2;
    }
}

懶漢式單例模式

$\color{red}{定義：}$ 被外部需要使用的時候才進行實例化。
$\color{red}{優(yōu)點：}$ 對內(nèi)存的利用率較高。
$\color{red}{缺點：}$ 性能較餓漢式較低，并發(fā)量較大的場景，容易造成線程阻塞，影響程序運行性能。
$\color{red}{適用場景：}$ 對內(nèi)存利用率要求較高，并發(fā)較低的場景。
$\color{red}{示例代碼：}$

public class LazySimpleSingleton {
    private LazySimpleSingleton() {
    }

    //靜態(tài)塊，公共內(nèi)存區(qū)域
    private static LazySimpleSingleton lazySimpleSingleton;

    //第一種無法保證現(xiàn)場安全，多線程調(diào)用存在多次實例化問題，即使得到的地址值相同也可能是多次實例化后的數(shù)據(jù)，可通過debug的Thead模式進行測試
    public static LazySimpleSingleton getInstance() {
        if(lazySimpleSingleton==null){
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }
    //第二種 加鎖保證程序的原子性，synchronized修飾的代碼只能串行訪問，所以影響程序性能。
    public static LazySimpleSingleton getInstanceSycn() {
        if (lazySimpleSingleton == null) {
            // 互斥鎖 鎖級別為類鎖，多線程只能串行訪問該資源
            synchronized (LazySimpleSingleton.class) {
                if (lazySimpleSingleton == null) {
                    lazySimpleSingleton = new LazySimpleSingleton();
                }
            }

        }
        return lazySimpleSingleton;
    }
}

懶漢式內(nèi)部類單例

從類初始化角度來考慮，可以采用靜態(tài)內(nèi)部類的方式；這樣即兼顧餓漢式的內(nèi)存浪費，又兼顧 synchronized 性能問題。
$\color{red}{示例代碼：}$

/**
 * LazyInnerClassSingleton類
 * 靜態(tài)內(nèi)部類
 * 兼顧餓漢式的內(nèi)存浪費，也兼顧 synchronized 性能問題
 * 內(nèi)部類一定是要在方法調(diào)用之前初始化，巧妙地避免了線程安全問題
 *
 * @author wangjixue
 * @date 2019-05-25 16:46
 */

public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton() {}

    //static:是為了使單例的空間在多個線程間共享
    //final : 保證這個方法不會被重寫，重載
    public static final LazyInnerClassSingleton getInstance() {
        //在返回結(jié)果以前，一定會先加載內(nèi)部類
        return LazyHodler.LAZY;
    }

    //默認(rèn)不加載
    private static class LazyHodler {
        //1.分配內(nèi)存地址 addr01 給LazyInnerClassSingleton對象
        //2.初始化LazyInnerClassSingleton對象
        //3.設(shè)置LAZY執(zhí)行該剛分配的地址addr01
        //因為 static：代表多個線程間訪問的成員變量LAZY是同一個成員變量。
        // final：代表映射的地址不變，所以每個線程T的成員變量LAZY指向的都是addr01對應(yīng)的實例。
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }

}

破壞單例

反射破壞單例

反射如何破壞單例：使用反射來調(diào)用其私有的構(gòu)造方法，然后再調(diào)用 newInstance()方法就會創(chuàng)建不同的實例。
$\color{red}{示例代碼：}$

/**
 * 通過反射方式獲取懶漢式內(nèi)部類單例對象
 */
class ReflectLazyInnerClassSingletonTest{

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        ////通過反射獲取私有的構(gòu)造方法
        Constructor<LazyInnerClassSingleton> constructor = LazyInnerClassSingleton.class.getDeclaredConstructor();
        // 強制訪問
        constructor.setAccessible(true);

        // 初始化，此次通過私有構(gòu)造方法new了兩次
        LazyInnerClassSingleton obj01 = constructor.newInstance();
        LazyInnerClassSingleton obj02 = constructor.newInstance();

        System.err.println(obj01);
        System.err.println(obj02);
        System.out.println("=========equal===========");
        System.err.println(obj02==obj01);

    }
}

$\color{red}{如何優(yōu)化：}$ 懶漢式內(nèi)部類單例：在其構(gòu)造方法中做一些限制，一旦出現(xiàn)多次重復(fù)創(chuàng)建，則直接拋出異常。
$\color{red}{示例代碼：}$

/**
 * LazyInnerClassSingleton類
 * 靜態(tài)內(nèi)部類
 * 兼顧餓漢式的內(nèi)存浪費，也兼顧 synchronized 性能問題
 *
 * @author wangjixue
 * @date 2019-05-25 16:46
 */

public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton() {
        //防止通過反射的方式獲取
        if(LazyHodler.LAZY!=null){
            throw new RuntimeException("禁止通過單例的私有構(gòu)造方法創(chuàng)建多個實例，因為違反了\"一個類在任何情況下都絕對只有一個實例\"的設(shè)計的初衷");
        }
    }
、、、
}

反序列化破壞單例

?當(dāng)我們將一個單例對象創(chuàng)建好，有時候需要將對象序列化然后寫入到磁盤，下次使用時再從磁盤中讀取到對象，反序列化轉(zhuǎn)化為內(nèi)存對象。反序列化后的對象會重新分配內(nèi)存，即重新創(chuàng)建。那如果序列化的目標(biāo)的對象為單例對象，就違背了單例模式的初衷，相當(dāng)于破壞了單例。

$\color{red}{示例代碼：}$

/**
 * SeriableLazyInnerClassSingleton類
 * 可序列化靜態(tài)內(nèi)部類
 * 兼顧餓漢式的內(nèi)存浪費，也兼顧 synchronized 性能問題
 * 但是反序列化會new出不同的對象實例。
 *
 * @author wangjixue
 * @date 2019-05-25 16:46
 */

public class SeriableLazyInnerClassSingleton implements Serializable {

    //序列化：將內(nèi)存中的數(shù)據(jù)寫入其他地方（硬盤，網(wǎng)絡(luò)IO）；
    //具體來說：序列化就是說把內(nèi)存中的狀態(tài)轉(zhuǎn)換成字節(jié)碼以I/O流的形式寫入硬盤等IO設(shè)備中永久的保存起來。



    //反序列化：將其他地方的數(shù)據(jù)寫入內(nèi)存
    //具體來說：將IO設(shè)備中保存的字節(jié)碼通過I/O流的形式讀取到內(nèi)存，并轉(zhuǎn)換成Java對象的過程就是反序列化。

    //注意：轉(zhuǎn)換成Java對象過程中會重新new對象實例；
private SeriableLazyInnerClassSingleton() {
        //防止通過反射的方式獲取
        if(LazyHodler.LAZY!=null){
            throw new RuntimeException("禁止通過單例的私有構(gòu)造方法創(chuàng)建多個實例，因為違反了\"一個類在任何情況下都絕對只有一個實例\"的設(shè)計的初衷");
        }
    }

    //static:是為了使單例的空間在多個線程間共享
    //final : 保證這個方法不會被重寫，重載
    public static final SeriableLazyInnerClassSingleton getInstance() {
        //在返回結(jié)果以前，一定會先加載內(nèi)部類
        return LazyHodler.LAZY;
    }

    //默認(rèn)不加載
    private static class LazyHodler {
        //1.分配內(nèi)存地址 addr01 給LazyInnerClassSingleton對象
        //2.初始化LazyInnerClassSingleton對象
        //3.設(shè)置LAZY執(zhí)行該剛分配的地址addr01
        //因為 static：代表多個線程間訪問的成員變量LAZY是同一個成員變量。
        // final：代表映射的地址不變，所以每個線程T的成員變量LAZY指向的都是addr01對應(yīng)的實例。
        private static final SeriableLazyInnerClassSingleton LAZY = new SeriableLazyInnerClassSingleton();
    }

}


/**
 * 通過反序列獲取單例測試
 */
public class SerializableLazyInnerClassSingletonTest {
    public static void main(String[] args) {
        // 通過反序列化得到的實例對象
        SeriableLazyInnerClassSingleton singleton01 = null;
        // 內(nèi)存中的實例對象
        SeriableLazyInnerClassSingleton singleton02 = SeriableLazyInnerClassSingleton.getInstance();

        try {
            //序列化到IO設(shè)備中
            FileOutputStream fos = new FileOutputStream("SeriableLazyInnerClassSingleton.class");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(singleton02);
            oos.flush();
            oos.close();

            //反序列化為Java對象
            FileInputStream fis = new FileInputStream("SeriableLazyInnerClassSingleton.class");
            ObjectInputStream ois = new ObjectInputStream(fis);
            singleton01 = (SeriableLazyInnerClassSingleton) ois.readObject();
            ois.close();

            System.err.println("singleton01 = "+singleton01);
            System.err.println("singleton02 = "+singleton02);
            System.out.println("======驗證========");
            System.err.println(singleton01==singleton02);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

$\color{red}{解決辦法：}$ 只需要在單例中增加 readResolve()方法即可。

public class SeriableLazyInnerClassSingleton implements Serializable {

    //序列化：將內(nèi)存中的數(shù)據(jù)寫入其他地方（硬盤，網(wǎng)絡(luò)IO）；
    //具體來說：序列化就是說把內(nèi)存中的狀態(tài)轉(zhuǎn)換成字節(jié)碼以I/O流的形式寫入硬盤等IO設(shè)備中永久的保存起來。



    //反序列化：將其他地方的數(shù)據(jù)寫入內(nèi)存
    //具體來說：將IO設(shè)備中保存的字節(jié)碼通過I/O流的形式讀取到內(nèi)存，并轉(zhuǎn)換成Java對象的過程就是反序列化。
    //注意：轉(zhuǎn)換成Java對象過程中會重新new對象實例；


    //防止反序列化new新的實例對象
    private Object readResolve(){
        return getInstance();
    }
、、、
}

?通過查看JDK源碼發(fā)現(xiàn)：ObjectInputStream 類的 readObject()方法首先調(diào)用ObjectStreamClass 的 isInstantiable()方法來判斷構(gòu)造方法是否為空，不為空返回true，（ $\color{red}{意味著：}$ 只要有無參構(gòu)造方法就會實例化。）驗證可以進行對象的實例化后調(diào)用hasReadResolveMethod()判斷 readResolveMethod 是否為空，不為空就返回 true。那么 readResolveMethod 是在哪里賦值的呢?通過全局查找找到了賦值代碼在私有方法 ObjectStreamClass()方法中給 readResolveMethod 進行賦值。

    readResolveMethod = getInheritableMethod( cl, "readResolve", null, Object.class);

?上面的邏輯其實就是通過反射找到一個無參的 readResolve()方法，并且保存下來。現(xiàn)在再回到 ObjectInputStream 的 readOrdinaryObject() 方法繼續(xù) 往下看，如果 readResolve()存在,則調(diào)用 invokeReadResolve()方法。在invokeReadResolve內(nèi)部通過反射方式調(diào)用readResolveMethod()方法。

Object invokeReadResolve(Object obj)
            throws IOException, UnsupportedOperationException
    {
        requireInitialized();
        if (readResolveMethod != null) {
            try {
                return readResolveMethod.invoke(obj, (Object[]) null);
            } catch (InvocationTargetException ex) { Throwable th = ex.getTargetException();
                if (th instanceof ObjectStreamException) {
                    throw (ObjectStreamException) th; } else {
                    throwMiscException(th);
                    throw new InternalError(th); // never reached }
                } catch (IllegalAccessException ex) {
            // should not occur, as access checks have been suppressed throw new InternalError(ex);
                }
            } else {
                throw new UnsupportedOperationException(); }
        
                }

?通過 JDK 源碼分析我們可以看出，雖然增加 readResolve()方法返回實例，解決了反序列化獲取單例被破壞的問題。但是，我們通過分析源碼以及調(diào)試，發(fā)現(xiàn)實際上單例對象實例化了兩次，只不過新創(chuàng)建的對象沒有被返回而已。如果，創(chuàng)建對象的動作發(fā)生頻率增大，就意味著內(nèi)存分配開銷也就隨之增大，那么如果解決多次創(chuàng)建的問題--注冊式單例。

注冊時單例

$\color{red}{定義：}$ 注冊式單例又稱為登記式單例，就是將每一個實例都登記到某一個地方，使用唯一的標(biāo)識獲取實例。注冊式單例有兩種寫法:一種為容器緩存，一種為枚舉登記。

枚舉單例
?枚舉式單例在靜態(tài)代碼塊中就給 INSTANCE 進行了賦值，是餓漢式單例的實現(xiàn)。

/**
 * EnumSingleton類
 * 枚舉注冊式單例
 * 《Effective Java》推薦的一種單例實現(xiàn)寫法
 *
 * @author wangjixue
 * @date 2019-05-26 00:17
 */
public enum  EnumSingleton {

    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}


/**
 * EnumSingletonTest類
 *
 * @author wangjixue
 * @date 2019-05-26 00:36
 */
public class EnumSingletonTest {
    public static void main(String[] args) {
        // 通過反序列化得到的實例對象
        EnumSingleton es01 = null ;
        // 內(nèi)存中的實例對象
        EnumSingleton es02 = EnumSingleton.getInstance();
        es02.setData(new Object());

        try {
            //序列化到IO設(shè)備中
            FileOutputStream fos = new FileOutputStream("EnumSingleton.seri");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(es02);
            oos.flush();
            oos.close();

            //反序列化為Java對象
            FileInputStream fis = new FileInputStream("EnumSingleton.seri");
            ObjectInputStream ois = new ObjectInputStream(fis);
            es01 = (EnumSingleton) ois.readObject();
            ois.close();

            System.err.println("EnumSingleton01 = "+es01.getData());
            System.err.println("EnumSingleton02 = "+es02.getData());
            System.out.println("======驗證========");
            System.err.println(es01==es02);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

?通過JDK 源碼，發(fā)現(xiàn) readObject0()中調(diào)用了 readEnum()方法
我們發(fā)現(xiàn)枚舉類型其實通過類名和 Class 對象類找到一個唯一的枚舉對象。因此，枚舉對象不可能被類加載器加載多次。

private Enum<?> readEnum(boolean unshared) throws IOException {
        if (bin.readByte() != TC_ENUM) {
            throw new InternalError();
        }
        ObjectStreamClass desc = readClassDesc(false);
        if (!desc.isEnum()) {
            throw new InvalidClassException("non-enum class: " + desc);
        }
        int enumHandle = handles.assign(unshared ? unsharedMarker : null);
        ClassNotFoundException resolveEx = desc.getResolveException();
        if (resolveEx != null) {
            handles.markException(enumHandle, resolveEx);
        }
        String name = readString(false);
        Enum<?> result = null;
        Class<?> cl = desc.forClass();
        if (cl != null) {
            try {
                @SuppressWarnings("unchecked")
                Enum<?> en = Enum.valueOf((Class) cl, name);
                result = en;
            } catch (IllegalArgumentException ex) {
                throw (IOException) new InvalidObjectException(
                        "enum constant " + name + " does not exist in " +
                                cl).initCause(ex);
            }
            if (!unshared) {
                handles.setObject(enumHandle, result);
            }
        }
        handles.finish(enumHandle);
        passHandle = enumHandle;
        return result;
    }

?那么反射是否能破壞枚舉式單例呢？同理通過JDK 源碼分析發(fā)現(xiàn)進入 Constructor 的 newInstance()方法，做了強制性的判斷，如果修飾符是 Modifier.ENUM 枚舉類型，直接拋出異常。

public T newInstance(Object... initargs)
            throws InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;  // read volatile if (ca == null) {
        ca = acquireConstructorAccessor();
    }

    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs); return inst;
}

?到這為止，我們分析處理枚舉式單例枚舉式單例也是《Effective Java》書中推薦的一種單例實現(xiàn)寫法。在 JDK 枚舉的語法特殊性，以及反射也為枚舉保駕護航，讓枚舉式單例成為一種比較優(yōu)雅的實現(xiàn)。

容器緩存
?容器式單例適用于創(chuàng)建實例非常多的場景，便于管理。但是是非線程安全的。

/**
 * ContainerSingleton類
 * 容器緩存式單例
 * 優(yōu)點：容器式寫法適用于創(chuàng)建實例非常多的情況，便于管理。
 * 缺點：非線程安全
 *
 * @author wangjixue
 * @date 2019-05-26 00:19
 */

public class ContainerSingleton {

    private ContainerSingleton() {}

    private static  Map<String ,Object> container = new ConcurrentHashMap<String ,Object>();

    public Object getBean(String className){

        synchronized (container){
            Object instance = null;
            if(!container.containsKey(className)){
                try {
                    instance = Class.forName(className).newInstance();
                    container.put(className,instance);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }else{
               instance= container.get(className);
            }
            return instance;
        }
    }
}

ThreadLocal 線程單例

?ThreadLocal 不能保證其創(chuàng)建的對象是全局唯一，但是能保證在單個線程中是唯一的，天生的線程安全。
$\color{red}{示例代碼：}$

/**
 * ThreadLocalSingleton類
 * ThreadLocal 不能保證其創(chuàng)建的對象是全局唯一，但是能保證在單個線程中是唯一的
 * @author wangjixue
 * @date 2019-05-26 00:52
 */
public class ThreadLocalSingleton {

    private ThreadLocalSingleton() {}

    // TODO: 2019-05-26 此處可與懶漢內(nèi)部類式單例進行比較 
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance = new ThreadLocal<ThreadLocalSingleton>(){
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };

    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}

/**
 * ThreadLocalSingletonTest類
 * ThreadLocal 不能保證其創(chuàng)建的對象是全局唯一，但是能保證在單個線程中是唯一的，具體原因如下：單例模式為了達(dá)到線程安全的目的，給方法上鎖，以時間換空間。ThreadLocal 將所有的對象全部放在 ThreadLocalMap 中，為每個線程都提供一個對象，實際上是以 空間換時間來實現(xiàn)線程間隔離的。
 * @author wangjixue
 * @date 2019-05-26 00:52
 */
public class ThreadLocalSingletonTest {

    public static void main(String[] args) {
        System.err.println(ThreadLocalSingleton.getInstance());
        System.err.println(ThreadLocalSingleton.getInstance());
        System.err.println(ThreadLocalSingleton.getInstance());
        System.err.println(ThreadLocalSingleton.getInstance()==ThreadLocalSingleton.getInstance());
        System.out.println("========多線程調(diào)用=======");

        Thread t1 = new Thread(new ThreadLocalExectorThread());
        Thread t2 = new Thread(new ThreadLocalExectorThread());
        t1.start();
        t2.start();
    }
}

class  ThreadLocalExectorThread implements Runnable{

    @Override
    public void run() {
        ThreadLocalSingleton lazy = ThreadLocalSingleton.getInstance();
        System.err.println(Thread.currentThread().getName()+"---"+lazy);
    }
}

總結(jié)

?單例模式可以保證內(nèi)存里只有一個實例，減少了內(nèi)存開銷;可以避免對資源的多重占用。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

2019-05-26 單列設(shè)計模式

2019-05-26 單列設(shè)計模式

單例模式

餓漢式單例模式

懶漢式單例模式

懶漢式內(nèi)部類單例

破壞單例

反射破壞單例

反序列化破壞單例

注冊時單例

ThreadLocal 線程單例

總結(jié)

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

2019-05-26 單列設(shè)計模式

單例模式

餓漢式單例模式

懶漢式單例模式

懶漢式內(nèi)部類單例

破壞單例

反射破壞單例

反序列化破壞單例

注冊時單例

ThreadLocal 線程單例

總結(jié)

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av