精华内容
下载资源
问答
  • 单例模式实例

    2019-02-22 14:29:20
    * 单例模式 */ private static OSSClientUtils ossClientUtils = null; /** * 定义私有构造器 */ private OSSClientUtils() { } /** * 定义一个公共的公开的方法来返回该类的实例 * * @return */ p...
    public class OSSClientUtils {
    
    /**
     * 单例模式
     */
    private static OSSClientUtils ossClientUtils = null;
    
    /**
     * 定义私有构造器
     */
    private OSSClientUtils() {
    }
    
    /**
     * 定义一个公共的公开的方法来返回该类的实例
     *
     * @return
     */
    public static synchronized OSSClientUtils getInstance() {
        if (ossClientUtils == null) {
            synchronized (OSSClientUtils.class) {
                if (ossClientUtils == null)
                    ossClientUtils = new OSSClientUtils();
            }
        }
        return ossClientUtils;
    }
    
    
    }
    展开全文
  • 单例模式实例之打印池: 打印池类图: 在操作系统中,打印池是一个用于管理打印任务的应用程序,通过打印池,用户可以删除、中止或者改变打印任务的优先级。在一个系统当中,往往只允许一个允许一个打印池对象,...

    单例模式实例之打印池:

    打印池类图:

    在操作系统中,打印池是一个用于管理打印任务的应用程序,通过打印池,用户可以删除、中止或者改变打印任务的优先级。在一个系统当中,往往只允许一个允许一个打印池对象,如果重复创建打印池,则抛出异常,现使用单例模式来模拟实现打印池的设计。

    在这节中,Java转C++需要注意几个点,类的静态变量需要在类外初始化,访问类的静态成员需要加类的作用域。还有一点是如果使用指针进行保存单例的话(如果用变量来实例单例,则无此问题,能正常调用析构函数),单例类是没有实例对象的,所以是无法调用析构函数来delete掉指针的,需要自己写函数来释放掉或者另辟方法,文中采用了内部静态实例类,来辅助实现释放指针。

    不过书上的单例模式有点不合理的地方,就是第二次获取单例对象的时候直接丢异常,我认为应该返回已经创建的单例对象,而不是丢异常,不过这也应该看实际要求是怎样的吧。

    单例类 PrintSpoolerSingleton (打印池类) :

    #include<iostream>
    #include<exception>
    using namespace std;
    
    
    //单例类 PrintSpoolerSingleton (打印池类) 
    class PrintSpoolerSingleton{
    public:
    	static PrintSpoolerSingleton* getInstance(){
    		if(instance == nullptr){
    			instance = new PrintSpoolerSingleton();
    		}else{
    			throw (char*)"打印池正在工作中!"; 
    		}
    		return PrintSpoolerSingleton::instance;//用类的作用域访问 
    	} 
    	void manageJobs(){
    		cout << "管理打印任务" << endl;
    	}
    	
    private:
    	static PrintSpoolerSingleton* instance;
    	
    	//私有(隐藏)构造函数,仅供类内调用,只调用一次 
    	PrintSpoolerSingleton(){
    		cout <<  "创建打印池!" << endl;
    	}
    	
    	~PrintSpoolerSingleton(){
    		//因为单例是指针,无法调用析构函数 ,需要辅助类实现 
    		
    	}
    	
    	//辅助类
    	class Free {
    	public:
    		Free(){}
    		~Free(){
    			if(instance != nullptr){
    				delete instance;
    				instance = nullptr;
    				cout << "打印池关闭!"  << endl; 
    			}
    		}
    	};
    	static Free m_free; //这里需要设为静态才行 ,且需要在外部实例化 
    };
    
    //C++静态变量需要在类外初始化 
    PrintSpoolerSingleton* PrintSpoolerSingleton::instance = nullptr;
    PrintSpoolerSingleton::Free PrintSpoolerSingleton::m_free;

     客户端测试类 :

    //客户端测试类 
    int main(void){
    	PrintSpoolerSingleton *ps1,*ps2;
    	
    	//这里测试ps1 
    	try{
    		ps1 = PrintSpoolerSingleton::getInstance();
    		ps1->manageJobs();
    	} catch(char *e){
    		cout << e << endl;
    	}
    	cout << "-----我是分割线-----" << endl;
    	
    	//这里测试ps2,测试是否已经创建单例实例,如果已经创建,则丢出异常 
    	try{
    		ps2 = PrintSpoolerSingleton::getInstance();
    		ps2->manageJobs();
    	} catch(char *e){
    		cout << e << endl;
    	}
    	return 0;
    } 

    输出:

     

    End

    展开全文
  • 泛型化单例模式实例

    泛型化单例模式,关键点为Class.newInstance(),构建无参的Class类的实例。写个例子记录一下(MyEclipse maven):

    src/main/java源文件夹下:

    club.younge.demo下新建单例获取类和实体类(Singleton, Student)

    Singleton:

    package club.younge.demo;
    
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * 泛型化单例模式
     * 
     * @author Younge
     *
     */
    public class Singleton {
    	@SuppressWarnings("rawtypes")
    	private static final ConcurrentHashMap<Class, Object> MAP = new ConcurrentHashMap<Class, Object>();
    
    	@SuppressWarnings("unchecked")
    	public static <T> T getInstance(Class<T> type) {
    		Object object = MAP.get(type);
    		if (object == null) {
    			try {
    				synchronized (MAP) {
    					object = type.newInstance(); //关键部分,通过类型创建无参实例
    					MAP.put(type, object);
    				}
    			} catch (InstantiationException e) {
    				e.printStackTrace();
    			} catch (IllegalAccessException e) {
    
    				e.printStackTrace();
    			}
    		}
    		return (T) object;
    	}
    	public static <T> void remove(Class<T> type){
    		MAP.remove(type);
    	}
    }
    

    Student:

    package club.younge.demo;
    
    public class Student {
    	private String number;
    	private String name;
    	public String getNumber() {
    		return number;
    	}
    	public void setNumberAndName(String number, String name){
    		this.number = number;
    		this.name = name;
    	}
    	public void setNumber(String number) {
    		this.number = number;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return new StringBuilder()
    		.append("I am a student, my number is ")
    		.append(this.number).append(",my name is ")
    		.append(this.name).toString();
    	}
    	
    }
    

    src/test/java源文件夹下:

    club.younge.demo下新建测试类(TestCC)

    TestCC:

    package club.younge.demo;
    
    import org.junit.Test;
    
    public class TestCC {
    
    	@Test
    	public void testSingleTon(){
    		Student student = Singleton.getInstance(Student.class);
    		student.setNumberAndName("123", "Haha");
    		System.out.println(student);
    	}
    }
    

    测试结果:

    I am a student, my number is 123,my name is Haha

    展开全文
  • 单例模式实例(全)

    千次阅读 2018-07-14 09:57:45
    什么是单例模式? 定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例场景,也就是说:确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象应该有且只有一...

    什么是单例模式?

    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例场景,也就是说:确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象应该有且只有一个。

    构建单例模式的关键:

    1.构造函数不对外开放,一般为Private

    2.通过一个静态方法或者枚举返回单例类对象

    3.确保单例类的对象有且只有一个,尤其是多线程的环境下

    4.确保单例类对象在反序列化时不会重新构建对象

    单例模式构建方式:

    1.饿汉模式

    2.懒汉模式(Double Check)

    3.静态内部类的单例模式

    4.容器实现单例模式

    5.序列化反序列化单例模式(readResolve)

    6.枚举单例模式

     

    代码示例:

    1.饿汉模式

    public class Singleton {
    	private Singleton(){
    	}
    	private static final Singleton Instance=new Singleton();
    	public static Singleton getInstance(){ 
    		return Instance;
    	}
    }

    2. 懒汉模式(Double Check)

    public class Singleton {
    	private Singleton(){
    	}
    	private static volatile Singleton Instance=null;
    	public static Singleton getInstance(){ 
    		if(Instance==null){
    			synchronized (Singleton.class) {
    				if(Instance==null)
    				{
    					Instance=new Singleton();
    					return Instance;
    				}
    			}
    		}
    		return Instance;
    	}
    }

    需要volatile关键字修饰Intance,volatile的语义是“禁止CPU对字节码指令重排序”,因为现在电脑是多核,所以JVM在运行的时候会将字节码指令进行重排序优化来更好的执行,所以这就可能会出现线程A的字节码指令执行到一半,线程B的字节码指令就去执行而首先对Intance进行修改,而导致线程A字节码执行到new的时候Intance已经被初始化。这时候就会有问题,所以需要禁止字节码重排序。

    3.静态内部类单例模式

    public class Singleton {
    	private Singleton(){}
    	private static Singleton getInstance(){
    		return SingletonHolder.Instance;
    	}
    	/**
    	 * 静态内部类
    	 */
    	private static class SingletonHolder{
    		private static final Singleton Instance = new Singleton();
    	}
    }

    当第一次加载Singleton类时,并不会初始化Instance,只有在第一次调用Singleton的getInstance方法时,才会导致 Instance 被初始化。第一次调用 getInstance 方法会导致虚拟机加载SingletonHolder类,这种方式不仅能够确保线程安全,也能够保证单例对象的唯一性,同时也延迟了单例对象的实例化,所以推荐使用这种方法。 

    4.使用容器实现单例模式

    public class SingletonManager {
        private static Map<String, Object> objMap = new HashMap<String, Object>();
        private SingletonManager(){ }
        //将多种单例类型注入到一个统一的管理类,在使用时根据key获取对象对应类型的对象
        public static void registerService(String key, Object instance)
        {
            if(!objMap.containsKey(key)){
                objMap.put(key, instance);
            }
        }
        public static Object getService(String key){
            return objMap.get(key);
        }
    }
    
     

    5.使用序列化实现单例模式

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
     
    public class SerSingleton implements Serializable {
     
        private static final long serialVersionUID = 1L;
        String name;
     
        private SerSingleton() {
            System.out.println("Singleton is create");
            name = "SerSingleton";
        }
     
        private static SerSingleton instance = new SerSingleton();
     
        public static SerSingleton getInstance() {
            return instance;
        }
     
        public static void createString() {
            System.out.println("createString in Singleton");
        }
    
        private Object readResolve(){
            return instance;
        }
    
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            SerSingleton s1 = null;
            SerSingleton s = SerSingleton.getInstance();
     
            FileOutputStream fos = null;
            ObjectOutputStream oos = null;
     
            FileInputStream fis = null;
            ObjectInputStream ois = null;
            try {
                fos = new FileOutputStream("SerSingleton.obj");
                oos = new ObjectOutputStream(fos);
                oos.writeObject(s);
            } finally {
                oos.flush();
                oos.close();
                fos.close();
            }
     
            try{
                fis = new FileInputStream("SerSingleton.obj");
                ois = new ObjectInputStream(fis);
                s1 = (SerSingleton) ois.readObject();
            }finally{
                ois.close();
                fis.close();
            }
            System.out.println(s == s1);
        }
    }

    序列化单例模式需要实现readResolve方法。

    6.使用enum实现单例模式

    public enum SingletonClass implements Serializable {
     
        INSTANCE;
        private static final long serialVersionUID = 1L;
     
        private String name;
     
        public void test() {
            System.out.println("The Test!");
        }
     
        public void setName(String name) {
            this.name = name;
        }
     
        public String getName() {
            return name;
        }
     
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            SingletonClass s1 = null;
            SingletonClass s = SingletonClass.INSTANCE;
     
            FileOutputStream fos = null;
            ObjectOutputStream oos = null;
     
            FileInputStream fis = null;
            ObjectInputStream ois = null;
            try {
                fos = new FileOutputStream("SingletonClass.obj");
                oos = new ObjectOutputStream(fos);
                oos.writeObject(s);
            } finally {
                oos.flush();
                oos.close();
                fos.close();
            }    
            try {
                fis = new FileInputStream("SingletonClass.obj");
                ois = new ObjectInputStream(fis);
                s1 = (SingletonClass) ois.readObject();
            } finally {
                ois.close();
                fis.close();
            }
            System.out.println(s == s1);
        }
    }

    这种容器单例模式的实现,在Android中,我们使用的Context的getSystemService(key)的方式,就是利用的容器单例模式。eg:WIndowsManagerService、ActivityManagerService等等。在虚拟机第一次加载该类时,会注册各种Service,这些服务以键值对的形式存储在一个HashMap中,用户使用时只需要根据key来获取到对应的具体服务对象了。

     

    展开全文
  • 5.5 单例模式实例

    2016-03-01 14:09:06
    单例模式的特点: 1: 单例类只有一个实例 2:单例类自己来创建 这个实例 3:单例类必须给其他对象提供这个实例 单例模式在Android 开发中的应用: 环信,Fresco,这些需要在Application 中进行初始化的。 ...
  • Java单例模式实例

    2012-08-02 09:21:41
    使用单例模式可以确保某个类只会有一个实例被创建。单例模式是通过下面的思想来保证的:不让类以外的任何事物创建对象的实例 。通常来讲,单例可以缩减内存 的需求。实现方式也有很多种。单例模式分三种:懒汉式...
  • PHP 单例模式实例与解析

    千次阅读 2017-06-26 17:25:35
    1、含义 作为对象的创建模式,单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统全局地提供这个实例。它不会创建实例副本,而是会向单例类内部存储的实例返回一个引用。2、单例模式的三个要点:(1). ...
  • 五种单例模式实例

    千次阅读 2016-05-10 18:20:15
    什么是单例模式? 定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例场景,也就是说:确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象应该有且只有一...
  • 本文是设计模式学习笔记的第二篇文章,主要分析的是单例模式。包括懒汉式,饿汉式,登记式,以及懒汉式的改进型,还有一个关于读取propertoes配置文件的实例。这是第四节,这次我们来看一下如何用单例模式配置配置...
  • 在C#中 单例的winform窗体再关闭之后会被释放,但是其单例的资源不是null,怎么回收?
  • 引言  单例模式是最常用到的设计模式之一。许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的... 单例模式就是指一个类永远只能实例化一次。使用
  • Java单例模式实例---读取配置文件

    千次阅读 2012-01-06 20:00:10
    因为配置文件里的信息都是一样...因此使用单例模式:只要实例化一次之后,有了一个对象,之后就不再需要实例化了。  为了配置文件修改的方便将配置文件的信息单独放到一个xml文件中。  oracle.jdbc
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
    本文继续介绍23种设计模式系列之单例模式。 概念:  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三... 单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例...
  • C# 单例模式实例

    2010-12-29 07:38:25
    C# 单例模式实例C# 单例模式实例C# 单例模式实例C# 单例模式实例C# 单例模式实例
  • 单例模式实例

    2020-05-17 15:41:19
    目录原型模式1、模式结构2、模式实例2.1 应用场景类图2.2 代码实现3、模式分析3.1 优点3.2 缺点3.3 适用场景 原型模式   单例模式是一种对象创建型模式,它提供了一种创建对象的方式,确保某一个类只有一个实例,...
  • 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。...当需要保证某个对象只能有一个实例的时候,单例模式非常有用。它把创建对象的控制权委托到一个单一的点上,任何时候应用程序...
  • 单例模式

    2017-10-07 14:12:21
    一、单例模式定义 单例模式的意思就是只有一个单例,单例模式确保某一个类只有一个实例,而且自行实例化并向整个...三、单例模式实例 a、饿汉式单例 //饿汉式单例类.在类初始化时,已经自行实例化 public c...
  • 细数单例模式

    万次阅读 2020-09-18 11:29:59
    单例模式是一个类对外仅提供一个实例对象,防止出现对象的不一致状态,与多例对象是对立的 单例模式有以下特点  1、单例类只能有一个实例。  2、单例类必须自己创建自己的唯一实例。  3、单例类必须给所有...
  • 单例模式 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保...
  • 测试方法调用单例模式的类,单例模式的类调用普通类,测试类调用单例模式的类两次,单例模式的类金实例化一次,被单例模式调用的类也只实例化一次, 需要强调的是,普通类是放在单例模式的类的构造方法中实例化的,...
  • IOS 单例设计模式实例Demo 单例 设计 模式 IOS Singleton
  • (转)单例模式

    2016-12-25 12:25:57
    单例模式 求助编辑百科名片   单例模式 ...单例模式实例 展开 单例模式简介 单例模式要点 优点: 单例模式实例 展开 编辑本段单例模式简介 单例模式(singleton)顾名思义,就是一个类只有一个实例
  • php单例模式使用实例之数据库连接

    千次阅读 2014-03-27 17:21:57
    单例模式是指整个应用中类只有一个对象实例的设计模式。 单例模式的特点 一个类在整个应用中只有一个实例类必须自行创建这个实例必须自行向整个系统提供这个实例 php中使用单例模式的原因 我用php大部分...
  • 设计模式 单例模式 优雅的单例模式

    千次阅读 2016-03-31 14:05:37
    单例模式可能是代码最少的模式了,但是少不一定意味着简单,想要用好、用对单例模式,还真得费一番脑筋。本文对Java中常见的单例模式写法做了一个总结,如有错漏之处,恳请读者指正。 饿汉法 顾名思义,饿汉法就是...
  • 单例模式饿汉式与懒汉式,内部类实现单例模式

    万次阅读 多人点赞 2020-11-08 19:17:07
    单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对持有一个实例,并提供一个全局访问点。 饿汉式单例模式 就是在类加载的时候就立即初始化,并且创建单例对象。绝对的线程安全 public class ...
  • 1.设计模式之终极结合 最近几期博客打算主要讲一下单例模式、观察者模式、Build模式,目的是为了方便后期为大家...单例模式顾名思义就是在一个App/Project中一个单例对象类只存在一个实例。比如我们一个App中是不是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,390
精华内容 14,956
关键字:

单例模式实例