zoukankan html css js c++ java

从头学习设计模式（一）——单例模式

from:http://www.cnblogs.com/ytaozhao/p/3385680.html

一、引入

　　单例模式作为23种设计模式中的最基础的一种模式，在平时开发中应用也非常普遍。到底哪些类应该设计成单例的呢，我们来举个最通俗的例子。在一个父容器中单击某个菜单项打开一个子窗口，如果不使用单例又没有作菜单项的可用控制的话，每次单击菜单项都会打开一个新窗口。这不仅会浪费内存资源，在程序逻辑上也是不可以接受的。

二、最简单的单例

　　下面来看一个最简单的单例模式的构造形式

    public class Program
    {
        private static void Main(string[] args)
        {

            GetInstance();
            Console.ReadLine();
        }

        private void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
                Console.WriteLine("Create a singleton instance!");
            }
            return instance;
        }
    }

　　这里通过几个关键的地方以保证返回唯一的实例：

私有的构造器，防止客户端用new关键字去创建实例对象
静态的instance对象，保证全局唯一性
对外的公共的静态实例方法，从类级别直接可调用此方法
通过判断null值，决定是创建新实例还是直接返回。

三、并发下的单例

　　不过，以上标准的单例构造模式在多并发的情况下就有可能失效，请参考下面的这种情况。

        private static void Main(string[] args)
        {
            //开启10个线程来模拟多并发的情况
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            if (instance == null)
            {
                instance = new Singleton();
                Console.WriteLine("Create a singleton instance!");
            }
            return instance;
        }
    }

　　以上的程序中开启了10个线程，来模拟多个用户同时访问getInstance方法。在getInstance方法里，开始先让线程睡一会，以模拟多个线程都已经进入了该方法。从运行的结果看上，基本上不能保证实例化唯一的实例了。

　　产生这种问题的原因就是，当一个线程进入getInstance 方法，通过了 instance==null 的条件，还没有来的及执行 instance = new Singleton() 时，另一个线程也通过了条件判断，这时就会 new Singleton() 多次了。

　　解决的办法就是加锁,只让一个线程进来，参考以下代码：

    public class Program
    {
        private static void Main(string[] args)
        {
            //开启100个线程来模拟多并发的情况
            for (int i = 0; i < 100; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private static readonly object objForLock=new object();
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            //加一道锁只让一个线程进来
            lock (objForLock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                    Console.WriteLine("Create a singleton instance!");
                }
            }
            return instance;
        }
    }

　　这样差不多可以达到我们的要求，只有一个实例对象存在可以保证了，但是这样会带来一点性能问题。如果每个线程进入getInstance方法后，都要lock一下以进行线程同步的话，每个线程到这里都要等待解锁后才能进入，但是如果 instance已经不是null了，那就应该直接返回而不是等待解锁，所以这里需要引入“双重锁”的单例构造方法，代码如下：

        private static void Main(string[] args)
        {
            //开启100个线程来模拟多并发的情况
            for (int i = 0; i < 100; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private static readonly object objForLock=new object();
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            //先判断是不是已经实例化过了，避免进入锁等待状态
            if(instance ==null)
            {
                //加一道锁只让一个线程进来
                lock (objForLock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                        Console.WriteLine("Create a singleton instance!");
                    }
                }
            }

            return instance;
        }
    }

四、“懒汉式”单例与“饿汉式”单例的比较

　　所谓的“懒汉式”与“饿汉式”，就是实例对象的初始化时间不同：

　　1. 在需要实例化的时候才进行实例化，就是懒汉式。我们上面的这些例子都是懒汉式的。懒汉式有好处当然是节省资源啦，需要的时候才去构造，平时不用占用内存。不过，这会带来上面提到的在多并发下需要加锁限制访问的问题。

　　2.类加载时就直接进行实例化，就是饿汉式。例如下面的代码：

    private static Singleton instance = new Singleton();
    
    private Singleton() {
        
    }
    
    public static Singleton getInstance() {
        return instance;
    }

　　饿汉式单例是当类第一次被加载时就会将instance进行实例化，这样作的好处是不会带来多并发下的线程安全问题了，也不用考虑锁了。但反过来带来的就是性能问题了，因为不管你需不需要将这个实例对象创建出来，它都已经被创建出来常驻内存了。所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。
　　这里只是对两种构造模式作了一个简单的对比，实际项目中要应用哪种模式还是要看具体需求而定。

作者：Tony zhao
出处：http://www.cnblogs.com/ytaozhao
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

正确的说法应该是类在第一次加载的时候会进行实例初始化，比如调用另外一个类的静态方法：这个例子里的时间是一样的。

public class Program
 {
     private static void Main(string[] args)
     {
         GetInstance();
         Console.ReadLine();
     }
 
     private static void GetInstance()
     {
         Console.WriteLine("begin:"+DateTime.Now.ToString());
         Singleton.DoSomeThing();
         Thread.Sleep(10000);
         DateTime objectSingleton = Singleton.getInstance();
         Console.WriteLine("call:" +objectSingleton.ToString());
     }
 }
 
 public class Singleton
 {
     private static DateTime instance =DateTime.Now ;
     private Singleton()
     {
     }
 
     public static DateTime getInstance()
     {
         return instance;
     }
     public static void  DoSomeThing()
     {
         //Do something..
     }
 }

查看全文

相关阅读:
SpringMVC访问静态资源
 tomcat 在linux下的关闭问题
 Mysql中MyISAM、InnoDB两种表类型的区别
 大数据——数据库优化
 for循环 java.lang.OutOfMemoryError: Java heap space
Tomcat内存溢出的三种情况及解决办法分析
 浅谈eclipse生成的.classpath文件(转)
深入理解java异常处理机制
 漫步ASP.NET MVC的处理管线
 用 javascript 获取当页面上鼠标（光标）位置

原文地址：https://www.cnblogs.com/liuqiyun/p/6677867.html