码迷，mamicode.com
首页 > 其他好文 > 详细

设计模式之单例模式

时间：2014-09-18 00:45:23      阅读：362      评论：0      收藏：0      [点我收藏+]

标签：des   style   blog   http   color   io   os   使用   java   

 

 

一、引子

 

首先来看两个常见的问题：

1.        单窗体的问题。

在主应用程序菜单点击菜单，弹出工具箱窗体，现在的问题是，希望工具箱要么不出现，出现也只可以出现一个，但是实际上每次点击菜单，都会实例化一个“工具箱”并显示出来，这样会产生很多个“工具箱”，不是所希望的。注意这里希望的是“工具箱”窗体单例，而不是进程单个实例(进程单个实例：例如PC上已经打开一个迅雷，再次运行迅雷，结果并没有再开一个迅雷而还是之前的，区分同一PC登陆多个QQ客户端)。

     bubuko.com,布布扣

如上图，每次单击菜单都会实例化一个工具箱窗体，与期望不符。

 

2. 大对象问题

 

对象有保存对象状态信息的一些字段，字段过多或者字段本身占据大量内存，都会导致对象过大。下面看一段示例：

class SimpleLargeObject
    {
        private const int NUM = 100 * 1024 * 1024;//100MB
        private byte[] data = null;

        public SimpleLargeObject()
        {
            data = new byte[NUM];
            for (int i = 0; i < data.Length; i++)
            {
                data[i] = (byte)(i % 255);
            }
        }

        public void Method1()
        {
            Console.WriteLine("Method1");
        }

        // other methods....

    }

    class Program
    {
        static void Main(string[] args)
        {
            SimpleLargeObject obj1=new SimpleLargeObject();
            obj1.Method1();
            Console.WriteLine("Press enter to create a new object...");
            Console.ReadLine();
            SimpleLargeObject obj2 = new SimpleLargeObject();
            obj2.Method1();
            Console.ReadLine();
        }
    }

为了更体现出问题，这里夸张一点，SimpleLargeObject占据内存100MB。

bubuko.com,布布扣

bubuko.com,布布扣

运行发现内存占据100MB，按回车键继续创建另外一个对象，此时内存翻倍增加至200MB…   可以想象，当特定环境下需要产生无数个对象，而这些对象本身的状态信息由私有字段来维护，字段的取值不同会影响到公开方法的行为，而这些对象又不需要在同一时刻都要存在，或者无数个这样的对象状态信息无关紧要，产生这么多对象会导致内存占用过多。

 

对于第一个问题，常规解决方法是在调用窗体类中声明一个ToolBoxForm类型的全局，判断这个ToolBoxForm类型的全局变量是否实例化过就行了。





private ToolBoxForm toolBoxForm = null;
        private void toolStripMenuItemToolBox_Click(object sender, EventArgs e)
        {
            if (toolBoxForm == null)
            {
                toolBoxForm = new ToolBoxForm();
                toolBoxForm.Show();
            }
        }






  这样似乎解决问题了。


  新需求来了：现在不但要在菜单里面启动“工具箱”，还需要在“工具栏”上的按钮来快捷启动“工具箱”。菜单栏有些常用的功能提供快捷按钮再正常不过的需求了。


 


bubuko.com,布布扣


  这个不难，增加一个工具栏控件，然后添加onclick事件，复制同样的代码就行了：




  private void toolStripButton1_Click(object sender, EventArgs e)
        {
            if (toolBoxForm == null)
            {
                toolBoxForm = new ToolBoxForm();
                toolBoxForm.Show();
            }
        }




  复制代码潜在的问题也是很明显的：


    

  1. 一份代码多出重复，如果需求变化或者有BUG时就需要改多个地方。如果有5个地方需要实例化“工具箱”窗体，这个小bug就需要改动5个地方，可见复制粘贴多么害人。
    2. 

  2. 复制粘贴是最容易的编程，也是最没有价值的编程，只求达到目标，如何能有提高。
    3. 



上面的程序就有潜在的Bug,启动“工具箱”，然后把“工具箱”窗体关闭，再点启动按钮，问题就暴露出来了。原因是关闭“工具箱”窗体时，它的实例并没有变为null,而只是Disposed。


Form.Show()方法出的窗体，关闭调用Close()会Dispose内存，对象销毁，但指向对象的引用不为null;


Form.ShowDilog()方法出的窗体，关闭窗体不会释放对象的内存，窗体的引用也不为null,窗体只是hidden而已。


 


上述Bug修复，并重构提炼方法后的代码：






private ToolBoxForm toolBoxForm = null;
        private void toolStripMenuItemToolBox_Click(object sender, EventArgs e)
        {
            OpenToolBox();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            OpenToolBox();
        }

        private void OpenToolBox()
        {
            if (toolBoxForm == null||toolBoxForm.IsDisposed)
            {
                toolBoxForm = new ToolBoxForm();
                toolBoxForm.Show();
            }
        }






  现在基本没什么问题了。


 


二 .类的职责


在上面几步的优化和改善，已经基本没什么问题了，但是这样做“工具箱”是否实例化都是在调用显示“工具箱”的地方来判断，这样不符合逻辑，主窗体里面应该只是通知启动“工具箱”，至于“工具箱”窗体是否实例化过，主窗体根本不关心，这不属于主窗体的职责，“工具箱”是否实例化过，应该有“工具箱”自己来判断。对象是否实例化是它自己的责任，而不是别人的责任，别人只是使用它就可以了。


对象的实例化其实就是new的过程，如果要控制对象的实例化由该类自身来维护，那么类的构造函数应该是私有的，这样外部就不能用new来实例化它了，而让这个类只能实例化一次，用静态的类变量能达到目的，因为静态是该类型共享的，而该类型刚好是这个类本身。


bubuko.com,布布扣


 


   客户端使用的代码：




private void toolStripMenuItem1_Click(object sender, EventArgs e)
        {
            ToolBoxForm.Instance.Show();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            ToolBoxForm.Instance.Show();        
        }




这样一来，客户端不再考虑是否需要去实例化的问题，而把责任都给了应该负责的类去处理。这就是一个很根本的设计模式：单例模式。


 


三、      单例模式


1.       基本的单例


定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。——GOF的《设计模式：可复用面向对象软件的基础》


通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且可以提供一个访问该实例的方法。


 




class Singleton
    {
        private static Singleton instance;

        private Singleton() //构造方法为private,这就堵死了外界利用new创建此类型实例的可能
        {
        }

        public static Singleton GetInstance() //次方法是获得本类实例的唯一全局访问点
        {
            if (instance == null)
            {
                instance = new Singleton();
            }

            return instance;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
           // Singleton s0 = new Singleton();//错误，外界不能通过new来创建此类型实例
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();
            if (s1 == s2)
            {
                Console.WriteLine("两个对象是相同的实例");
            }

            Console.ReadLine();
        }
 }




 运行结果，s1和s2是同一个实例，都是通过唯一的全局访问点Singleton.GetInstance()方法返回的。


 


2.       多线程环境下的单例


先模拟一个多线程的环境：




class Singleton
    {
        private static Singleton instance;

        private Singleton() //构造方法为private,这就堵死了外界利用new创建此类型实例的可能
        {
           Thread.Sleep(50);//此处模拟创建对象耗时
        }

        public static Singleton GetInstance() //次方法是获得本类实例的唯一全局访问点
        {
            if (instance == null)
            {
                instance = new Singleton();
            }

            return instance;
        }
    }

    class Program
    {
        const int THREADCOUNT = 200;
        static List<Singleton> sList = new List<Singleton>(THREADCOUNT);
        static object objLock = new object();
      
        static void Main(string[] args)
        {
            Task[] tasks=new Task[THREADCOUNT];

            for (int i = 0; i < THREADCOUNT; i++)
            {
                tasks[i] = Task.Factory.StartNew(ThredFunc);
            }
           
            Task.WaitAll(tasks);//确保所有任务执行完毕
            Console.WriteLine("sList.Count:" + sList.Count);

            int index1 = -1;
            int index2 = -1;
            if(HasDifferentInstance(out index1,out index2))
            {
                Console.WriteLine("含有不相同的实例,index1={0},index2={1}", index1, index2);
            }
            

            Console.WriteLine("执行完毕.");
            Console.ReadLine();
            
        }

        private static bool HasDifferentInstance(out int index1,out int index2)
        {
            index1 = index2 = -1;
            for (int i = 0; i < sList.Count; i++)
            {
                for (int j = i + 1; j < sList.Count - 1; j++)
                {
                    if (sList[i] != sList[j])
                    {                    
                        index1 = i;
                        index2 = j;
                        return true;
                        
                    }
                }
            }
            return false;
        }

        private static void ThredFunc()
        {
            Singleton singleton = Singleton.GetInstance();
            lock (objLock)
            {
                sList.Add(Singleton.GetInstance());
            }
        }




bubuko.com,布布扣


 


我们在Singleton的构造函数延迟50ms来模拟创建对象耗时，这样在多线程的环境下，很容易出现在一个线程执行Singleton.GetInstance()时创建对象，而这个对象的创建理论上是要消耗时间的，在创建对象之前instance为null,还未返回，此时另一个线程也执行Singleton.GetInstance()判断instance为null，执行了new创建了对象，这样出现了对象实例不为同一个对象的情况。


为了解决这个问题，在执行new创建实例的地方加上锁，同时在锁定之前判断下是否为null,这样如果已经创建就不用进入锁了。


 




public static Singleton GetInstance() //次方法是获得本类实例的唯一全局访问点
        {
            if (instance == null)
            {
                lock (objLock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }




对于instance存在的情况，就直接返回；当instance为null并且同时有两个线程GetInstance()方法时，它们都可以通过第一重instance==null的判断，然后由于lock机制，这两个线程则只有一个进入，另一个在排队等候，必须要其中的一个进入并出来后，另一个才能进入。而此时如果没有了第二重的instance是否为null的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，所以需要两次判断。


 


进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。但是，这种实现方法在平时的项目开发中用的很好，也没有什么问题？但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。


   上面的Doule-Check Locking(双重锁定) 能进一步优化，利用CLR类型构造器保证线程安全：


 




 class Singleton
    {
        private static Singleton instance;

        static Singleton()  //类型构造器，确保线程安全
        {
            instance = new Singleton();
        }

        private Singleton() //构造方法为private,这就堵死了外界利用new创建此类型实例的可能
        {
           Thread.Sleep(50);//此处模拟创建对象耗时
        }

        public static Singleton GetInstance() //次方法是获得本类实例的唯一全局访问点
        {          
            return instance;
        }
    }




不需要null判断，代码更加精炼，又能避免加锁解锁。


 


四、      C++ 单例模式


尽管单例模式的思想是一致的，但是C++ 与C#有很多不同点，甚至有时候用到语言平台的独有特性有意想不到的效果，例如利用CLR的特性，类型构造器能确保线程安全性。这里介绍一下C++实现单例模式。 利用GOF中单例模式的定义，很容易写出如下的代码：


版本一：




 class Singleton
{
private:
    Singleton()
    {
    }
    static Singleton * m_pInstance;

public:
    static Singleton * GetInstance()
    {
        if (m_pInstance == NULL)
        {
            m_pInstance = new Singleton();
        }
        return m_pInstance;
    }
};
Singleton * Singleton::m_pInstance = NULL;




用户访问唯一实例的方法只有GetInstance()成员函数。如果不通过这个函数，任何创建实例的尝试都将失败，因为类的构造函数是私有的。GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的，所有GetInstance()之后的调用都返回相同实例的指针：


 




Singleton *p1 = Singleton::GetInstance();
 Singleton *p2 = Singleton::GetInstance();
 Singleton *p3 = p2;




P1、p2都是通过GetInstance()全局访问点访问的，指向的是同一实例，p3是经过指针赋值，也是指向同一实例，它们的地址相同：


bubuko.com,布布扣


 


大多数时候，这样的实现都不会出现问题。有经验的读者可能会问，m_pInstance指向的空间什么时候释放呢？这样会不会导致内存泄漏呢？


我们一般的编程观念是，new操作是需要和delete操作进行匹配的；是的，这种观念是正确的。具体看场景。static Singleton * m_pInstance;m_pInstance 指针本身为静态的，存储方式为静态存储，生命周期为进程周期；而其指向的实例对象在堆上分配，这个堆对象有个特点就是只有一个实例，堆内存由程序员释放或程序结束时可能由OS回收。


 


堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。


 


注意，这里是可能。具体能不能得看OS，目前windows是可以的，而嵌入式系统有些是不能的。所以还得看场景。


在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，尽管这个指向实例的指针为静态的,而这个实例为堆中对象并且只有一个，进程结束后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。而针对服务端程序，一般是长期运行，但是这个实例也只有一个，进程结束，操作系统会回收内存。


显然，把内存回收的责任交给OS，虽然大多数情况下是没问题的，但是还是看场景的，内存能不能回收也取决于OS内核。


更重要的是，在以下情形，是必须需要进行实例销毁的：


在类中，有一些文件锁了，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；


 


版本二：添加手动释放函数




class Singleton
{
private:
    Singleton()
    {
    }
    static Singleton * m_pInstance ;

public:
    static Singleton * GetInstance()
    {
        if (m_pInstance == NULL)
        {
            m_pInstance = new Singleton();
        }
        return m_pInstance;
    }

    static void DestoryInstance()
    {
        if (m_pInstance != NULL)
        {
            delete m_pInstance;
            m_pInstance = NULL;
        }
    }
};




   我们单例类中添加一个DestoryInstance()函数来删除实例，可以在进程退出之前来调用这个函数释放，结合前面“类的职责”小结，很快会发现这样不是很优雅，理想情况下是类的使用者只管拿来用，而不用关注什么时候释放，并且程序员忘了调用这个函数也是很容易发生的事。能不能实现像boost中shared_ptr<T>这样自动释放内存呢？


由于这个实例的生命周期为直到进程结束，因此可以设计一个包装类作为静态变量，静态变量的生命周期也是到进程结束销毁，可以在这个包装类的析构函数里面释放资源。


以下是改进版本：


版本三：利用RAII自动释放


 




class Singleton
{
private:
    Singleton()
    {
    }
    static Singleton * m_pInstance ;

    class GC //内部包装类
    {
    public:
        ~GC()
        {
            if (m_pInstance != NULL)
            {
                std::cout << "Here is the test，delete m_pInstance." << std::endl;
                delete m_pInstance;
                m_pInstance = NULL;
            }
        }
    };

    static GC m_gc;
public:
    static Singleton * GetInstance()
    {
        if (m_pInstance == NULL)
        {
            m_pInstance = new Singleton();
        }
        return m_pInstance;
    }

};

Singleton * Singleton::m_pInstance = NULL;//这里初始化Singleton的静态成员m_pInstance
Singleton::GC Singleton::m_gc;//这里初始化Singleton里面嵌套类GC的静态成员m_gc

int _tmain(int argc, _TCHAR* argv[])
{
    
    Singleton *p1 = Singleton::GetInstance();
    Singleton *p2 = Singleton::GetInstance();
    std::cin.get();
    return 0;
}




 


运行程序，执行到cin.get()后敲回车，程序即将退出，输出以下结果：


bubuko.com,布布扣




说明嵌套类GC的析构函数已经执行。此处使用了一个内部GC类，而该类的作用就是用来释放资源，其定义在Singleton的private部分，外部无法访问，也不关心。程序在结束的时候，系统会自动析构所有的全局变量，实际上，系统也会析构所有类的静态成员变量，就像这些静态变量是全局变量一样。我们知道，静态变量和全局变量在内存中，都是存储在静态存储区的，所以在析构时，是同等对待的。在程序运行结束时，系统会调用Singleton的静态成员static GC m_gc的析构函数，该析构函数会进行资源的释放，而这种资源的释放方式是在程序员“不知道”的情况下进行的，而程序员不用特别的去关心，使用单例模式的代码时，不必关心资源的释放。这里运用了C++中的RAII机制。


 


RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源。


            前面的各个版本还没考虑多线程的问题，参考前面C#版本的“双检锁”，而C++语言本身不提供多线程支持的，多线程的实现是由操作系统提供支持的，可以用系统API。这里用


C++ 0x 的线程库，C++ 0x里面部分库由boost发展而来。


版本四： 多线程环境下“双检锁”




class Singleton
{
private:
    Singleton()
    {
    }
    static Singleton * m_pInstance;
    class GC //内部包装类
    {
    public:
        ~GC()
        {
            if (m_pInstance != NULL)
            {
                std::cout << "Here is the test，delete m_pInstance." << std::endl;
                delete m_pInstance;
                m_pInstance = NULL;
            }
        }
    };

    static GC m_gc;
    static std::mutex m_mutex;
public:
    static Singleton * GetInstance()
    {
        if (m_pInstance == NULL)
        {
            m_mutex.lock();
            if (m_pInstance == NULL)
            {
                m_pInstance = new Singleton();
            }
            m_mutex.unlock();
        }
        return m_pInstance;
    }

};

Singleton * Singleton::m_pInstance = NULL;//这里初始化Singleton的静态成员m_pInstance
Singleton::GC Singleton::m_gc;//这里初始化Singleton里面嵌套类GC的静态成员m_gc
std::mutex Singleton::m_mutex; //初始化Singleton静态成员m




这里使用了C++ 0x的mutex,需要#include <mutex>


继续参考之前C#版本的优化，提供静态初始化版本：


版本五：静态初始化


 




class Singleton
{
private:
    Singleton()
    {
    }
    const static Singleton * m_pInstance;
    class GC //内部包装类
    {
    public:
        ~GC()
        {
            if (m_pInstance != NULL)
            {
                std::cout << "Here is the test，delete m_pInstance." << std::endl;
                delete m_pInstance;
                m_pInstance = NULL;
            }
        }
    };

    static GC m_gc;
public:
    static Singleton * GetInstance()
    {        
        return const_cast<Singleton *>(m_pInstance);
    }

    void TestMethod()
    {
        std::cout << "Singleton::TestMethod" << std::endl;
    }
};

const Singleton* Singleton::m_pInstance = new Singleton(); //这里静态初始化
Singleton::GC Singleton::m_gc;//这里初始化Singleton里面嵌套类GC的静态成员m_gc
int _tmain(int argc, _TCHAR* argv[])
{

    Singleton *p1 = Singleton::GetInstance();
    Singleton *p2 = Singleton::GetInstance();
    p1->TestMethod();
    std::cin.get();
    return 0;
}




 


因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。


 


语言特性


下面我们看看其它版本，先不考虑多线程(多线程问题前面讨论过了，不做重点，也可以在主函数之前以单线程方式先完成初始化来达到目的)。


 




class Singleton
{
private:
    Singleton()
    {
    }
public:
    static Singleton&  GetInstance()
    {
        static Singleton instance;
        return instance;
    }
    void TestMethod()
    {
        std::cout << "Singleton::TestMethod()" << std::endl;
    }
};




这个版本不再使用指针，而是返回一个静态局部变量的引用。也许有人会问，返回局部变量的引用，局部变量过了作用域就析构了啊，但是注意这里是静态局部变量，存储


方式为静态存储，生命周期为到进程退出，所以不用担心函数结束就析构了。C# 和Java等没有静态局部变量的概念，这个可以说是C/C++的一个特性。


写程序测试：




int _tmain(int argc, _TCHAR* argv[])
{
    
    Singleton::GetInstance().TestMethod();
    Singleton s1= Singleton::GetInstance();
    Singleton s2 = s1;
    if (addressof(s1) == addressof(s2))
    {
        cout << "同一实例" << endl;
    }
    else
    {
        cout << "不同实例" << endl;
        cout <<"s1的地址："<<(int)(&s1) << endl;
        cout <<"s2的地址：" <<(int)(&s2) << endl;
    }
    std::cin.get();
    return 0;
}




bubuko.com,布布扣


 


发现s1和s2是不同的实例，这是因为对象的创建除了构造函数外还有其他方式，例如复制构造函数、赋值操作符等，都需要禁止。


 


改进版本：


 




class Singleton
{
private:
    Singleton()
    {
    }
    Singleton(const Singleton&) = delete;//禁止复制
    Singleton operator=(const Singleton&) = delete;//禁止赋值操作
public:
    static Singleton&  GetInstance()
    {
        static Singleton instance;
        return instance;
    }
    void TestMethod()
    {
        std::cout << "Singleton::TestMethod()" << std::endl;
    }
};




 


这样，外部企图通过赋值操作符或者复制来创建对象，都会报错:


bubuko.com,布布扣


Singleton::GetInstance() 是唯一的全局访问点和访问方式。


 


项目中出现多个需要用到单例的类怎么办？分别编写禁止复制构造函数、禁止赋值操作，分别编写GetInstance()方法 这种重复的工作？我们宏可以解决这个重复性工作：




#define  SINGLINTON_CLASS(class_name)     private:    class_name(){}    class_name(const class_name&);    class_name& operator = (const class_name&);    public:    static class_name& Instance()    {      static class_name one;      return one;    }


class Simple
{
    SINGLINTON_CLASS(Simple)

public:
    void Print()
    {
        cout<<"Simple::Print()"<<endl;
    }
};




可以把上面的宏写到一个头文件中，在需要写单例的地方include这个头文件，单例类开头只需加上SINGLINTON_CLASS(class_name)就行了，其中class_name为当前类名，然后可以讲工作重心放到这个类的设计上。


客户的还是照样调用：




int _tmain(int argc, _TCHAR* argv[])
{
    Simple::Instance().Print();
    
    cin.get();
    return 0;
}




 


总结


单例模式可以说是设计模式里面最基本和简单的一种了，为了写这篇文章，自己调查了很多方面的资料，例如《大话设计模式》，同时加上C++各个版本的实现和自己的理解，如有错误，请大家指正。


在实际的开发中，并不会用到单例模式的这么多种版本，每一种设计模式，都应该在最适合的场合下使用，在日后的项目中，应做到有地放矢，而不能为了使用设计模式而使用设计模式。




 
设计模式之单例模式
标签：des   style   blog   http   color   io   os   使用   java   
原文地址：http://www.cnblogs.com/sndnnlfhvk/p/3978363.html

                

                

                    

                        

                            

                                

                                    踩

                                

                                    (0)

                            

                            

                                

                                    赞

                                

                                    (0)

                            

                        

                        

                            

                                    
                                
                            

                        

                    

                    

                        举报
                    

                    
                    

                        

                            评论 一句话评论（0）
                        

                        

                            
                            

                                
                            

                        

                        

                            

                            

                                

                                

                                

                                    
                                

                            

                            

                                登录后才能评论！
                                
                            

                            

                        

                    

                

                
            

        

        

            
            





            
            


    

        

            分享档案

        

            更多>
        

    

    

        
                
                    2021年07月29日
                    (22)

            
                
                    2021年07月28日
                    (40)

            
                
                    2021年07月27日
                    (32)

            
                
                    2021年07月26日
                    (79)

            
                
                    2021年07月23日
                    (29)

            
                
                    2021年07月22日
                    (30)

            
                
                    2021年07月21日
                    (42)

            
                
                    2021年07月20日
                    (16)

            
                
                    2021年07月19日
                    (90)

            
                
                    2021年07月16日
                    (35)

            
    




            


    

        
周排行

        

            mamicode.com排行更多图片

        

            更多

    

    

        
    




            
        

        

        

    

    
    

    

        

            友情链接
        

        

            兰亭集智  
			国之画  
			百度统计   
			 站长统计  
			阿里云  
			chrome插件  
			新版天听网
        

    





    

        

            关于我们 - 联系我们 - 留言反馈
        

        

            © 2014 mamicode.com
            版权所有   联系我们:gaon5@hotmail.com
        

        

            迷上了代码！