单例模式及Lock()

 

namespace ConsoleApplication1
{
    public class SimpleDemo
    {
        /*
         * public string name;
         * public static SimpleDemo instance;
         * public SimpleDemo(string _n)
         * {
         * instance = this;
         * name = _n;
         * }
         * public void Show()
         * {
         * Console.WriteLine(instance.name);
         * }
         */


        /* static  被静态修饰的变量，在内存中只有一份 */
        public static SimpleDemo instance;
        public static SimpleDemo Getinstance( string n )
        {
            if ( instance == null )
            {
                instance    = new SimpleDemo();
                instance.name    = n; /* 因为instance是SimpleDemo的实例，所以name是可以调出来的 */
            }
            return(instance);
        }

        /* ..其他的还可以写其他的属性字段 */
        public string name;
    }
    class Program
    {
        static void Main( string[] args )
        {
            SimpleDemo s6 = SimpleDemo.Getinstance( "s6" );
            Console.WriteLine( s6.name );
            SimpleDemo s2 = SimpleDemo.Getinstance( "s2" );
            Console.WriteLine( s2.name );
            /*
             * 输出的结果都是s6，因为在开始运行到s6的时候，instance是未创建的，是空的；所以会创建一个新的实例,
             * 等到第二次去运行s2的时候,instance已经创建完成了，直接返回的还是s6的实例，
             * 无论创建多少的SimpleDemo的实例，返回的都是同一个值
             * 用处：思考了一下，感觉和修饰词Const一样，修饰了那个词，那个词的值就定了;只不过这里是可以让一个对象的值定了。
             *      比如，超市一类物品属性值固定，就给这一类写个单例模式;
             * 单例模式，单例模式，就是这个类被实例化了一次，所有的属性就定了；不管你再实例化多少，结果还是同样的,
             * 实例再多还是"单例"
             */

            /*
             * SimpleDemo s1 = new SimpleDemo("4");
             * SimpleDemo s2 = new SimpleDemo("2");
             * s1.Show();//这个是声明几个，会出现几个值，是特殊的单例模式
             * Console.ReadKey();
             */
            Console.ReadKey();
        }
    }
}

 

单例模式的目的就是，确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源。

先写一个单例的类
public Class SingleClass
{
   //单机模式的第一步，就是要把这个单例类的构造函数的修饰改为private，让这个类无法在外边被实例化
    private SingleClass
    {
    }
   //单机模式的第一步，不能从外边被实例化，就得从内部实例化，再提供一个获取这个使力的接口函数。
    static  SingleClass  SignClass=null;
    static  Object obj=new Object();
    public  static  SingleClass GetInstance()
    {
         if(SignClass==null)
         {
         locker(obj)
            {          
              SignClass=new SingleClass();
            }

         }
      return SingClasss;

    }

}

如果SingClass==null,就实例化一个新的出来；如果已经实例化了，就直接返回；
其中的Lock锁，是为了避免多个线程同时多个实例化。

单例模式的讲解
红色部分呢注释掉就不是单例了。

 

 

 

 

 bilibili

 访问数据库或者读写IO的时候，也可以用单例模式来减少资源的消耗。

 整个系统！！！！！

还有这种Lock的写法,

Lock(Typeof(int))

{逻辑代码}

 

 

c# lock (obj) 与 lock (this) 区别

lock(obj) 锁定 obj 对象

lock(this) 锁定 当前实例对象，如果有多个类实例的话，lock锁定的只是当前类实例，对其它类实例无影响。

使用lock需要注意的地方：
1.lock不能锁定空值某一对象可以指向Null，但Null是不需要被释放的。（请参考：认识全面的null）
2.lock不能锁定string类型，虽然它也是引用类型的。因为字符串类型被CLR“暂留”
3.lock锁定的对象是一个程序块的内存边界
4.值类型不能被lock，因为前文标红字的“对象被释放”，值类型不是引用类型的
5.lock就避免锁定public 类型或不受程序控制的对象。

lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。也就是，说在多线程中，使用lock关键字，可以让被lock的对象，一次只被一个线程使用。
lock语句根本使用的就是Monitor(检测器)  Monitor.Enter和Monitor.Exit,
也就是说lock(this)时执行Monitor.Enter(this),大括号结束时执行Monitor.Exit(this).
也就是说，Lock关键字，就是一个语法糖而已。

 

String在CLR中有两个重要的属性：不变性和字符串驻留。
这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了==>所有运行的应用程序域的所有线程中的该文本。
因此，只要===>>>在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，
就将==>锁定 应用程序中该字符串的所有实例。

因此，最好锁定不会被暂留的私有或受保护成员。

Ｃ#中字符串 "驻留"与Lock(转载) (bbsmax.com)