本文目录
- C++刚学单例模式的代码，对你们来说很简单，麻烦帮解答一下
- js写一个单例模式代码,并且加上双检查.
- java中的单例模式的代码怎么写
- C++单例模式
- android 几种单例模式的写法
C++刚学单例模式的代码，对你们来说很简单，麻烦帮解答一下
#include 《iostream》 //头文件using namespace std; //命名空间class Singelton //单例类{public:static Singelton* GetInstance() //提供了一个获取该单例类实指针的静态函数{if (instance_ == NULL) //判断该实例是否存在{instance_=new Singelton; //不存在的话new一个}return instance_; //存在的话直接返回}private:Singelton() //该单例类的构造函数{}static Singelton* instance_; //该单例类的实例，静态};Singelton*Singelton::instance_;int main(){Singelton *s=Singelton::GetInstance(); //直接获取该单例类实例，因为不存在，所以这里会new一个Singelton *s2=Singelton::GetInstance(); //直接获取该单例类实例，因为存在了，所以直接返回，此时s==s2}
js写一个单例模式代码,并且加上双检查.
在不采用webwork的情况下，js本身就是单线程，没有必要采用单例，如果一定要用，需要根据不同的需求，采用不同的实现方式，比如：function Single(){ this.name=’557176536’;// 定义你的属性}Single.Ins=function() {// 单例的实现 if(!Single._init){ Single.ins=new Single(); Single._init=true; } return Single.ins;};Single.prototype.show=function(){//调用 alert(this.name);}Single.Ins().show();
java中的单例模式的代码怎么写
我从我的博客里把我的文章粘贴过来吧，对于单例模式模式应该有比较清楚的解释：单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。一般说来，单例模式通常有以下几种：1.饥汉式单例public class Singleton { private Singleton(){}; private static Singleton instance = new Singleton(); public static Singleton getInstance(){ return instance; }}这是最简单的单例，这种单例最常见，也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时，单例就会被加载到内存中。在这里我们可以做个这样的测试：将上述代码修改为：public class Singleton { private Singleton(){ System.out.println(“createSingleton“); }; private static Singleton instance = new Singleton(); public static Singleton getInstance(){ return instance; } public static void testSingleton(){ System.out.println(“CreateString“); }}而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）public class TestSingleton { @Test public void test(){ Singleton.testSingleton(); }}输出结果：createSingletonCreateString 我们可以注意到，在这个单例中，即使我们没有使用单例类，它还是被创建出来了，这当然是我们所不愿意看到的，所以也就有了以下一种单例。2.懒汉式单例public class Singleton1 { private Singleton1(){ System.out.println(“createSingleton“); } private static Singleton1 instance = null; public static synchronized Singleton1 getInstance(){ return instance==null?new Singleton1():instance; } public static void testSingleton(){ System.out.println(“CreateString“); }}上面的单例获取实例时，是需要加上同步的，如果不加上同步，在多线程的环境中，当线程1完成新建单例操作，而在完成赋值操作之前，线程2就可能判断instance为空，此时，线程2也将启动新建单例的操作，那么多个就出现了多个实例被新建，也就违反了我们使用单例模式的初衷了。我们在这里也通过一个测试类，对它进行测试，最后面输出是CreateString可以看出，在未使用到单例类时，单例类并不会加载到内存中，只有我们需要使用到他的时候，才会进行实例化。这种单例解决了单例的延迟加载，但是由于引入了同步的关键字，因此在多线程的环境下，所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。public class TestSingleton { @Test public void test(){ long beginTime1 = System.currentTimeMillis(); for(int i=0;i《100000;i++){ Singleton.getInstance(); } System.out.println(“单例1花费时间：“+(System.currentTimeMillis()-beginTime1)); long beginTime2 = System.currentTimeMillis(); for(int i=0;i《100000;i++){ Singleton1.getInstance(); } System.out.println(“单例2花费时间：“+(System.currentTimeMillis()-beginTime2)); }}最后输出的是：单例1花费时间：0单例2花费时间：10 可以看到，使用第一种单例耗时0ms，第二种单例耗时10ms，性能上存在明显的差异。为了使用延迟加载的功能，而导致单例的性能上存在明显差异，是不是会得不偿失呢？是否可以找到一种更好的解决的办法呢？既可以解决延迟加载，又不至于性能损耗过多，所以，也就有了第三种单例：3.内部类托管单例public class Singleton2 { private Singleton2(){} private static class SingletonHolder{ private static Singleton2 instance=new Singleton2(); } private static Singleton2 getInstance(){ return SingletonHolder.instance; }}在这个单例中，我们通过静态内部类来托管单例，当这个单例被加载时，不会初始化单例类，只有当getInstance方法被调用的时候，才会去加载SingletonHolder，从而才会去初始化instance。并且，单例的加载是在内部类的加载的时候完成的，所以天生对线程友好，而且也不需要synchnoized关键字，可以说是兼具了以上的两个优点。4.总结一般来说，上述的单例已经基本可以保证在一个系统中只会存在一个实例了，但是，仍然可能会有其他的情况，导致系统生成多个单例，请看以下情况：public class Singleton3 implements Serializable{ private Singleton3(){} private static class SingletonHolder{ private static Singleton3 instance = new Singleton3(); } public static Singleton3 getInstance(){ return SingletonHolder.instance; }}通过一段代码来测试：@Test public void test() throws Exception{ Singleton3 s1 = null; Singleton3 s2 = Singleton3.getInstance(); //1.将实例串行话到文件 FileOutputStream fos = new FileOutputStream(“singleton.txt“); ObjectOutputStream oos =new ObjectOutputStream(fos); oos.writeObject(s2); oos.flush(); oos.close(); //2.从文件中读取出单例 FileInputStream fis = new FileInputStream(“singleton.txt“); ObjectInputStream ois = new ObjectInputStream(fis); s1 = (Singleton3) ois.readObject(); if(s1==s2){ System.out.println(“同一个实例“); }else{ System.out.println(“不是同一个实例“); } }输出：不是同一个实例 可以看到当我们把单例反序列化后，生成了多个不同的单例类，此时，我们必须在原来的代码中加入readResolve()函数，来阻止它生成新的单例public class Singleton3 implements Serializable{ private Singleton3(){} private static class SingletonHolder{ private static Singleton3 instance = new Singleton3(); } public static Singleton3 getInstance(){ return SingletonHolder.instance; } //阻止生成新的实例 public Object readResolve(){ return SingletonHolder.instance; }}再次测试时，就可以发现他们生成的是同一个实例了。
C++单例模式
1、构造方法私有 那么，就意味着，只能在Singleton的成员函数中，才能调用Singleton的构造函数来创建实例。在Singleton之外，不能创建Singleton对象的实例。2、代码中，定义了GetInstance方法，只能通过GetInstance方法来获取Singleton对象的实例，单例就是在GetInstance方法中控制的。首先，Singleton有一个static Singleton* instance;//惟一实例 Singleton* Singleton::instance=NULL;在这里初始化为NULL。Singleton* Singleton::GetInstance() { if(instance == NULL) { instance = new Singleton(); } return instance; } 上面的函数，就是通过instance来实现单例的。当第一次调用GetInstance时，instance 为NULL，所以会执行instance = new Singleton();把这个新建的实例保存到静态成员instance，并返回这个指针。第二次到第N次调用GetInstance时，由于instance不为空，所以会直接返回instance 。也就是第一次调用GetInstance创建的那个实例。所以这样就实现了，单实例。意思就是说，Singleton对象的实例，只会被创建一次，就是说内存中，只存在一个Singleton的实例，就是所谓，单实例。
android 几种单例模式的写法
先不论单例模式的写法，有些方面是相同的，比如都需要将唯一的对象设置为static的，都需要将构造方法private化，代码如下：public class MyInstance { private static MyInstance instance; private MyInstance(){}}第一种：最原始的单例模式，代码如下：public static MyInstance getInstance(){ if(instance==null){ instance=new MyInstance();} return instance;}多线程并发时，可能会出现重复new对象的情况，因此不提倡使用。第二种：将整个方法块进行加锁，保证线程安全。public static synchronized MyInstance getInstance(){ if(instance==null){ instance=new MyInstance();} return instance;}这种代码下，每条线程都会依次进入方法块内部，虽然实现了单例，但是影响了运行效率，可以使用但是也不怎么提倡。第三种：进一步优化的方法。public static MyInstance getsInstance(){ synchronized (MyInstance.class){ if(instance==null){ instance=new MyInstance(); return instance;}else{ return instance;}}}这种方式只是第二种方法的一种优化，但是优化有限。（以下的几种方法比较推荐使用）第四种：双层判断加锁，效率影响小且保证了线程安全。public static MyInstance getsInstance() { if (instance == null) { synchronized (MyInstance.class) { if(instance==null){ instance=new MyInstance();}}} return instance;}这种方法是对第二种和第三种方法的进一步优化，比较推荐使用。第五种：内部类实现单例，不用线程锁来实现效率的提升。public class MyInstance { private MyInstance() {} public static MyInstance getInstance(){ return MyInstanceHolder.instance;} private static class MyInstanceHolder{ private static MyInstance instance=new MyInstance();}}在内部类中new对象，再将内部类的对象返回，这种方法是使用了java中class加载时互斥的原理来实现了线程的安全。不加线程锁也使得运行效率不会受到较大的影响。比较提倡。