1. 创建型模式 (1) 单例模式

andrew7676

浏览: 176176 次
性别:
来自: 北京

最近访客更多访客>>

权律二

xingming_03

dongcaoheneric

dongguangming88

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

2019-04 ( 38)
2019-03 ( 20)
2019-02 ( 34)
更多存档...

博客分类：

DesPattern

java 设计模式

1. 创建型模式 (3) 单例模式

单例模式是为确保一个类只有一个实例，并为整个系统提供一个全局访问点的一种模式方法。
    （1）在任何情况下，单例类永远只有一个实例存在
    （2）单例需要有能力为整个系统提供这一唯一实例

1. 饿汉式单例模式

线程安全

饿汉式单例是指在方法调用前，实例就已经创建好了。

package com.andrew.pattern0101.singleton.modal01;

/**
 * 1.饿汉式单例模式
 * 线程安全
 * 饿汉式单例是指在方法调用前，实例就已经创建好了。
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = new SingletonTest();
    
    private SingletonTest(){};
    
    public static SingletonTest getInstance() {
        return instance;
    }
}

package com.andrew.pattern0101.singleton.modal01;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

2. 懒汉式单例模式

(1) 简单懒汉式单例模式

线程可能不安全

懒汉式单例是指在方法调用获取实例时才创建实例。

package com.andrew.pattern0101.singleton.modal0201;

/**
 * 2.懒汉式单例模式
 * (1)简单懒汉式单例模式
 * 线程可能不安全
 * 懒汉式单例是指在方法调用获取实例时才创建实例。
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        // 下面代码无法在多线程下保证实例的唯一性
        if (null == instance) {
             instance = new SingletonTest();
        }
        return instance;
    }
}

package com.andrew.pattern0101.singleton.modal0201;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

(2) 有间隔的懒汉式单例模式

线程不安全

懒汉式单例是指在方法调用获取实例时才创建实例。

package com.andrew.pattern0101.singleton.modal0202;

/**
 * 2.懒汉式单例模式
 * (2)有间隔的懒汉式单例模式
 * 线程不安全
 * 懒汉式单例是指在方法调用获取实例时才创建实例。
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        // 下面代码无法在多线程下保证实例的唯一性
        // 应当在创建实例之前可能会有一些准备性的耗时工作
        // 但是仍然无法保证单例的线程安全
        try {
            if (null != instance) {
            } else {
                Thread.sleep(300);
                instance = new SingletonTest();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }    
}

package com.andrew.pattern0101.singleton.modal0202;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

3. 线程安全的懒汉式单例模式

(1) 使用同步锁机制synchronized

线程安全

懒汉式单例是指在方法调用获取实例时才创建实例。
为了保证线程安全，要使用同步锁机制，在方法中声明synchronized关键字

package com.andrew.pattern0101.singleton.modal0301;

/**
 * 3.线程安全的懒汉式单例模式
 * (1)使用同步锁机制synchronized
 * 线程安全
 * 懒汉式单例是指在方法调用获取实例时才创建实例。
 * 为了保证线程安全，要使用同步锁机制，在方法中声明synchronized关键字
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public synchronized static SingletonTest getInstance() {
        // 应当在创建实例之前可能会有一些准备性的耗时工作，并声明同步锁synchronized关键字
        // 但是这种方法效率很低
        try {
            if (null != instance) {
            } else {
                Thread.sleep(300);
                instance = new SingletonTest();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }
}

package com.andrew.pattern0101.singleton.modal0301;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

(2) 使用同步代码块

线程安全

懒汉式单例是指在方法调用获取实例时才创建实例。
为了保证线程安全，提高同步锁效率，使用同步代码块实现

package com.andrew.pattern0101.singleton.modal0302;

/**
 * 3.线程安全的懒汉式单例模式
 * (2)使用同步代码块
 * 线程安全
 * 懒汉式单例是指在方法调用获取实例时才创建实例。
 * 为了保证线程安全，提高同步锁效率，使用同步代码块实现
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        // 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率
        try {
            synchronized (SingletonTest.class) {
                if (null != instance) {
                } else {
                    Thread.sleep(300);
                    instance = new SingletonTest();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }    
}

package com.andrew.pattern0101.singleton.modal0302;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

(3) 使用同步代码块(针对某些重要的代码进行单独的同步，而不是全部进行同步)

线程可能不安全

懒汉式单例是指在方法调用获取实例时才创建实例。
为了保证线程安全，提高同步锁效率，使用同步代码块实现

package com.andrew.pattern0101.singleton.modal0303;

/**
 * 3.线程安全的懒汉式单例
 * (3)使用同步代码块(针对某些重要的代码进行单独的同步，而不是全部进行同步)
 * 线程可能不安全
 * 懒汉式单例是指在方法调用获取实例时才创建实例。
 * 为了保证线程安全，提高同步锁效率，使用同步代码块实现
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        try {
            if (null != instance) {
            } else {
                Thread.sleep(300);
                // 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率,但是只同步一部分
                synchronized (SingletonTest.class) {
                    instance = new SingletonTest();    
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }
}

package com.andrew.pattern0101.singleton.modal0303;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

(4) 双检查锁机制单例(推荐)

线程安全

<1>采用DCL的双检查锁机
<2>使用volatile关键字保其可见性

package com.andrew.pattern0101.singleton.modal0304;

/**
 * 3.线程安全的懒汉式单例
 * (4).双检查锁机制单例(推荐)
 * <1>采用DCL的双检查锁机
 * <2>使用volatile关键字保其可见性
 * 线程安全
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    // 使用volatile关键字保其可见性
    volatile private static SingletonTest instance = null;
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        try {
            if (null != instance) {
            } else {
                Thread.sleep(300);
                // 应当在创建实例之前可能会有一些准备性的耗时工作，并使用synchronized同步代码块来提高效率,但是只同步一部分
                synchronized (SingletonTest.class) {
                    // 在实例化之前进行二次检查
                    if (null == instance) {
                        instance = new SingletonTest();        
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }    
}

package com.andrew.pattern0101.singleton.modal0304;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

4. 使用静态内置类实现单例模式

线程安全

package com.andrew.pattern0101.singleton.modal04;

/**
 * 4.使用静态内置类实现单例模式    
 * 线程安全
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    // 内部类
    private static class SingletonTestHandler{
        private static SingletonTest instance = new SingletonTest();
    }
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        return SingletonTestHandler.instance;
    }    
}

package com.andrew.pattern0101.singleton.modal04;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

5. 序列化与反序列化的单例模式

(1) 未使用readResolve方法的单例模式

线程不安全

序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样，说明反序列化后返回的对象是重新实例化的，单例被破坏了。

package com.andrew.pattern0101.singleton.modal0501;

import java.io.Serializable;

/**
 * 5.序列化与反序列化的单例模式
 * (1)未使用readResolve方法的单例模式
 * 线程不安全
 * 序列号对象的hashCode和反序列化后得到的对象的hashCode值不一样，说明反序列化后返回的对象是重新实例化的，单例被破坏了
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest implements Serializable {
    
    private static final long serialVersionUID = 1L;
    
    // 内部类
    private static class SingletonTestHandler{
        private static SingletonTest instance = new SingletonTest();
    }
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        return SingletonTestHandler.instance;
    }
}

package com.andrew.pattern0101.singleton.modal0501;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SaveAndReadForSingleton {

    public static void main(String[] args) {
        SingletonTest singletonTest = SingletonTest.getInstance();
        File file = new File("MySingleton.txt");
        try {  
            FileOutputStream fos = new FileOutputStream(file);  
            ObjectOutputStream oos = new ObjectOutputStream(fos);  
            oos.writeObject(singletonTest);  
            fos.close();  
            oos.close();  
            System.out.println(singletonTest.hashCode());  
        } catch (FileNotFoundException e) {   
            e.printStackTrace();  
        } catch (IOException e) {   
            e.printStackTrace();  
        }
        
        try {  
            FileInputStream fis = new FileInputStream(file);  
            ObjectInputStream ois = new ObjectInputStream(fis);  
            SingletonTest rsingletonTest = (SingletonTest) ois.readObject();  
            fis.close();  
            ois.close();  
            System.out.println(rsingletonTest.hashCode());  
        } catch (FileNotFoundException e) {   
            e.printStackTrace();  
        } catch (IOException e) {   
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {   
            e.printStackTrace();  
        }
    }    
}

1028566121
455659002

(2) 使用readResolve方法的单例模式

线程不安全

readResolve方法在反序列化时会被调用，实现反序列化

package com.andrew.pattern0101.singleton.modal0502;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 5.序列化与反序列化的单例模式
 * (2)使用readResolve方法的单例模式
 * 线程不安全
 * readResolve方法在反序列化时会被调用，实现反序列化
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest implements Serializable {
    
    private static final long serialVersionUID = 1L;
    
    // 内部类
    private static class SingletonTestHandler{
        private static SingletonTest instance = new SingletonTest();
    }
    
    private SingletonTest() {}
    
    public static SingletonTest getInstance() {
        return SingletonTestHandler.instance;
    }
    
    // 该方法在反序列化时会被调用，该方法不是接口定义的方法，有点儿约定俗成的感觉
    protected Object readResolve() throws ObjectStreamException {  
        System.out.println("调用了readResolve方法！");  
        return SingletonTestHandler.instance;   
    }
}

package com.andrew.pattern0101.singleton.modal0502;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SaveAndReadForSingleton {

    public static void main(String[] args) {
        SingletonTest singletonTest = SingletonTest.getInstance();
        File file = new File("MySingleton.txt");
        try {  
            FileOutputStream fos = new FileOutputStream(file);  
            ObjectOutputStream oos = new ObjectOutputStream(fos);  
            oos.writeObject(singletonTest);  
            fos.close();  
            oos.close();  
            System.out.println(singletonTest.hashCode());  
        } catch (FileNotFoundException e) {   
            e.printStackTrace();  
        } catch (IOException e) {   
            e.printStackTrace();  
        }
        
        try {  
            FileInputStream fis = new FileInputStream(file);  
            ObjectInputStream ois = new ObjectInputStream(fis);  
            SingletonTest rsingletonTest = (SingletonTest) ois.readObject();  
            fis.close();  
            ois.close();  
            System.out.println(rsingletonTest.hashCode());  
        } catch (FileNotFoundException e) {   
            e.printStackTrace();  
        } catch (IOException e) {   
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {   
            e.printStackTrace();  
        }
    }
}

1028566121
调用了readResolve方法！
1028566121

6. 使用static代码块实现模式

线程安全

静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性的实现单例设计模。

package com.andrew.pattern0101.singleton.modal06;

/**
 * 6.使用static代码块实现模式
 * 线程安全
 * 静态代码块中的代码在使用类的时候就已经执行了，所以可以应用静态代码块的这个特性的实现单例设计模。
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class SingletonTest {
    
    private static SingletonTest instance = null;
    
    private SingletonTest(){};
    
    static {
        instance = new SingletonTest();
    }
    
    public static SingletonTest getInstance() {
        return instance;
    }
}

package com.andrew.pattern0101.singleton.modal06;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(SingletonTest.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

7. 使用枚举数据类型实现单例模式

线程安全

枚举enum和静态代码块的特性相似，在使用枚举时，构造方法会被自动调用。

package com.andrew.pattern0101.singleton.modal07;

/**
 * 7.使用枚举数据类型实现单例模式
 * 线程安全
 * 枚举enum和静态代码块的特性相似，在使用枚举时，构造方法会被自动调用。
 * 
 * @author andrew
 * @date 2018/04/23
 */
public enum EnumFactory {
    
    singletonFactory;
    
    private SingletonTest instance;
    
    private EnumFactory(){
        // 枚举类的构造方法在类加载是被实例化  
        instance = new SingletonTest();  
    }
    
    public SingletonTest getInstance(){
        return instance;
    }
    
}

class SingletonTest {
    // 需要获实现单例的类，比如数据库连接Connection
    public SingletonTest(){}
}

package com.andrew.pattern0101.singleton.modal07;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(EnumFactory.singletonFactory.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

8. 完善使用enum枚举实现单例模式

线程安全
不暴露枚举类实现细节

package com.andrew.pattern0101.singleton.modal08;

/**
 * 8.完善使用enum枚举实现单例模式
 * 线程安全
 * 不暴露枚举类实现细节
 * 
 * @author andrew
 * @date 2018/04/23
 */
public class ClassFactory {
    
    private enum EnumSingletonTest {
        
        singletonFactory;
        
        private SingletonTest instance;
        
        private EnumSingletonTest() {
            // 枚举类的构造方法在类加载是被实例化
            instance = new SingletonTest();
        }
        
        public SingletonTest getInstance(){
            return instance;
        }
    }
    
    public static SingletonTest getInstance(){  
        return EnumSingletonTest.singletonFactory.getInstance();  
    }
}

class SingletonTest {
    // 需要获实现单例的类，比如数据库连接Connection
    public SingletonTest(){};
}

package com.andrew.pattern0101.singleton.modal08;

public class ThreadTest extends Thread {
    
    @Override
    public void run() {
        System.out.println(ClassFactory.getInstance().hashCode());
    }
    
    public static void main(String[] args) {
        ThreadTest[] tts = new ThreadTest[10];
        for (int i = 0; i < tts.length; i++) {
            tts[i] = new ThreadTest();
        }
        for (int j = 0; j < tts.length; j++) {
            tts[j].start();
        }
    }
}

总结：推荐使用 3.线程安全的懒汉式单例模式 (4) 双检查锁机制单例(推荐)

补充说明

参照博客：https://blog.csdn.net/cselmu9/article/details/51366946

分享到：

1. 创建型模式 (2) 原型模式 | Java设计模式 23种设计模式

2018-09-12 13:42
浏览 400
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

1. 创建型模式 (1) 单例模式

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

1. 创建型模式 (1) 单例模式

评论

发表评论

相关推荐

3. 行为型模式 (11) 解释器模式

3. 行为型模式 (10) 中介者模式

3. 行为型模式 (9) 访问者模式

3. 行为型模式 (8) 状态模式

3. 行为型模式 (7) 备忘录模式

3. 行为型模式 (6) 命令模式

3. 行为型模式 (5) 责任链模式

3. 行为型模式 (4) 迭代子模式

3. 行为型模式 (3) 观察者模式

3. 行为型模式 (2) 模板方法模式

3. 行为型模式 (1) 策略模式

2. 结构型模式 (3) 代理模式

2. 结构型模式 (7) 享元模式

2. 结构型模式 (6) 组合模式

2. 结构型模式 (2) 装饰者模式

2. 结构型模式 (5) 桥接模式

2. 结构型模式 (4) 外观模式

2. 结构型模式 (1) 适配器模式

1. 创建型模式 (2) 原型模式

1. 创建型模式 (3) 建造者模式

最近访客更多访客>>