attributes && reflections &&Thread&&Synchronization

1.属性和反射

属性是对目标元素的相关数据的代表。

同时C# 还具有一个反射系统，可用来检索用自定义属性定义的信息。（否则自定义属性没什么意义，不过老师说可以用一些软件来查看，比如书上说的：ILDasm）

老师讲的比较快，听得不是很清楚，后来翻了翻书，看到“自定义属性”的内容，进行了尝试。

这个例子是把程序的错误信息绑定到代码的特定修正中（特定修正？），然后利用反射将元数据输出到console流里。

namespace CustomAttributes
{
    //create attributes
    [AttributeUsage(AttributeTargets.Class|AttributeTargets.Constructor|AttributeTargets.Field
                    |AttributeTargets.Method|AttributeTargets.Property,AllowMultiple = true)]
    public class BugFixAttribute : System.Attribute
    {
        //private class member
        private int bugID;
        private string comment;
        private string date;
        private string programmer;
        //按声明顺序导入参数  构造函数
        public BugFixAttribute(int bugID, string programmer, string date)
        {
            this.bugID = bugID;
            this.programmer = programmer;
            this.date = date;
        }
        //只读参数访问器
        public int BugID
        {
            get { return bugID; }
        }
        //带名参数的特征
        public string Comment
        {
            get { return comment; }
            set { comment = value; }
        }
        public string Date
        {
            get { return date; }
        }
        public string Programmer
        {
            get { return programmer; }
        }
         
    }
    [BugFixAttribute(121,"mark","15/04/30")]
    [BugFixAttribute(107,"mark","15/05/02",Comment= "fixed off by one error")]

    public class MyMath
    {
        public double f1(double p1)
        {
            return p1 + f2(p1);
        }
        public double f2(double p1)
        {
            return p1 / 3;
        }
    }
    public class Tester
    {
        public static void Main ()
        {
            MyMath mm = new MyMath();
            Console.WriteLine("call f（7）.result：{0}", mm.f1(7));
            
            //获得成员信息并检索自定义属性
            System.Reflection.MemberInfo inf = typeof(MyMath);
            object[] attributes;
            attributes = inf.GetCustomAttributes(typeof(BugFixAttribute), false);

            //遍历属性并检索
            foreach( Object attribute in attributes)
            {
                BugFixAttribute bfa = (BugFixAttribute)attribute;
                Console.WriteLine("
BugID:{0},bfa {0}", bfa.BugID);
                Console.WriteLine("Programmer: {0}", bfa.Programmer);
                Console.WriteLine("Date: {0}", bfa.Date);
                Console.WriteLine("Comment: {0}", bfa.Comment);
            }
        }
    }
}

结果为：

其中代码的后半段的反射所使用的主要方法是 GetCustomAttributes，它返回对象数组，这些对象在运行时等效于源代码属性。

2.线程与同步

1）创建线程

线程使程序在同一时间内做不同的事情。

多处理器：快（同时进行）

单处理器：慢（交替进行），来回切换

下面创建了2个线程，分别从0数到1000和从1000数到0

public static void Main ()
        {
            Tester t = new Tester();
            Console.WriteLine("let us begin the threading testing!");
            t.DoTest();

        }
        public void DoTest()
        {
            Thread t1 = new Thread(new ThreadStart(f1));
            Thread t2 = new Thread(new ThreadStart(f2));
            t1.Start();
            t2.Start();
        }
        public void f1()
        {
            for(int i = 0; i < 1000; i++)
            {
                System.Console.WriteLine("f1:{0}", i);
            }
        }
        public void f2()
        {
            for (int i = 1000; i > 0; i--)
            {
                System.Console.WriteLine("f2:{0}", i);
            }
        }

结果为：可知，两个线程是交替进行的。

2）拼接线程

把t2.Join();写入t1的一个函数里，运行时t1将会挂起等待知道t2结束。

3）通过睡眠阻塞线程

加Thread.Sleep(),会让线程有机会在另一个线程打印一个值的时候运行。例如将1）中加入sleep，则结果变为：

4）中断线程

推荐的方法：设置布尔标记KeepAlive,线程间隔地检测这个值，当标记改变状态时，线程可以自己停止自己。

（这是百度到的教程里的代码和讲解，感觉比课本里的清晰，但是好像用的是interrupt课本的略乱）

代码中声明了两个线程，创建两线程的委托实例，例子是输出从1到50的整数，并在输出10，20和30之后使线程睡眠；输出从51到99的整数，并自动检测线程sleeper的状态，当sleeper处于WaitSleepJoin时，调用Interrupt使其回到调度队列：

public class SleepAndInterrupt

{
  //声明两线程
    public static Thread sleeper;
    public static Thread interrupter;
    public static void Main()
    {
        Console.WriteLine("进入Main");
        //创建两线程的委托实例
        sleeper = new Thread(new ThreadStart(SleepThread));
        interrupter = new Thread(new ThreadStart(InterruptThread));
        //开始执行两线程
      sleeper.Start();
        interrupter.Start();
        Console.WriteLine("退出Main");
    }
    //输出从1到50的整数，并在输出10，20和30之后使线程睡眠
    public static void SleepThread()
    {
        for(int i = 1; i <= 50; i++)
        {
           Console.Write (i+" ");
            if(i == 10 || i == 20 || i == 30)
            {
                Console.WriteLine("在{0}处进入睡眠", i);
                //捕捉使线程睡眠抛出的异常
                try
                {
                    Thread.Sleep(10);
                }
                catch
                {
                }
            }
        }
    }
    //输出从51到99的整数，并自动检测线程sleeper的状态
    //当sleeper处于WaitSleepJoin时，调用Interrupt使其回到调度队列
    public static void InterruptThread()
    {
        for(int i = 51; i < 100; i++)
        {
            Console.Write(i+" ");
            //判断线程sleeper的当前状态
            if(sleeper.ThreadState == System.Threading.ThreadState.WaitSleepJoin)
            {
                Console.WriteLine("中断睡眠中的线程");
                sleeper.Interrupt();
            }
        }
    }
}

结果为：

 5）同步

同步通过对对象加锁实现，帮助程序员阻止另一个线程闯入你的对象，知道第一个线程不再使用这个对象为止。

同步有三种方式：互锁类，c#lock语句，监控器器对象。

首先模拟一个共享资源：

namespace SharedResource
 {
     class Tester
     {
         private int counter = 0;
          static void Main()
         {
             Tester t = new Tester();
             t.DoTest();
         }
         public void DoTest()
          {
              Thread t1 = new Thread(new ThreadStart(f1));
              t1.IsBackground = true;
              t1.Name = "threadOne";
              t1.Start();
              Console.WriteLine("Started thread {0}", t1.Name);
              Thread t2 = new Thread(new ThreadStart(f1));
              t2.IsBackground = true;
              t2.Name = "threadOne";
              t2.Start();
              Console.WriteLine("Started thread {0}", t2.Name);

              t1.Join();
              t2.Join();

             //所有线程结束后打印一个消息
              Console.WriteLine("ALL thread are done.");
          }
         public void f1()
         {
             try
             {
                 while(counter < 1000)
                 {
                     int temp = counter;
                     temp++;
                     Thread.Sleep(1);

                     counter = temp;
                     Console.WriteLine("Thread {0}.f1:{1}", Thread.CurrentThread.Name, counter);
                 }
             }
             catch (ThreadInterruptedException)
             {
                 Console.WriteLine("thread{0} interrupted! Cleaning up...", Thread.CurrentThread.Name);

             }
             finally
             {
                 Console.WriteLine("Thread{0} existing.", Thread.CurrentThread.Name);
             }
         }

     }
 }

结果为：（部分）

然后使用互锁（Interlocked）

改变上文中方法的try语句

             try
             {
                 while(counter < 1000)
                 {
                     int temp = Interlocked.Increment(ref counter);                  
                     Thread.Sleep(0);
                     Console.WriteLine("Thread {0}.f1:{1}", Thread.CurrentThread.Name, temp);
                 }
             }

结果为（部分）：

此时对成员counter的访问就是同步的。

然后是更广泛使用的同步机制c#lock，其可以控制对其他对象的访问，其标记了代码中的一个临界区，当锁有效的时候对指定的对象提供同步机制。

将代码中try改为：

             try
             {
                 while(counter < 1000)
                 {
                     int temp;                  
                     Thread.Sleep(0);
                     lock(this)
                     {
                         temp = counter;
                         temp++;
                         Thread.Sleep(1);
                         counter = temp;
                     }
                     Console.WriteLine("Thread {0}.f1:{1}", Thread.CurrentThread.Name, temp);
                 }
             }

输出与互锁相同。

over