整理 C# 多线程常用的几个对象和方法

Thread 几个中要的方法

     Sleep(int):静态方法，暂停当前线程指定的毫秒数

     Abort():通常使用该方法来终止一个线程  ，Thread.ResetAbort() 可以恢复终止的线程
     Suspend():不是终止未完成的线程，它仅仅是挂起线程，还可以恢复（已过期,但还是可以用）

     Resume()://恢复被Suspend()方法挂起的线程的执行（已过期可以用）

Join()：给创建一个子线程，给它加了这个方法，其它线程就会暂停执行，直到这个线程执行完为止才去执行（包括主线程），

下面的例子如果不加join()方法，两个线程和主线程是并行执行的。如加上Join()方法，就会等到执行完，再执行下面的代码

Thread threadA = new Thread(SleepMethod);     //执行的必须是无返回值的方法 
            threadA.Name = "小A";
            //threadA.Start(); 启动线程

            Thread threadB = new Thread(SleepMethod);
            threadB.Name = "小B";

            threadA.Start(); //启动线程

            //Join通俗的说就是创建一个子线程，给它加了这个方法，其它线程就会暂停执行，直到这个线程执行完为止才去执行（包括主线程）
            threadA.Join();
            threadB.Start();
            threadB.Join();
            
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("我是:主线程,我循环{1}次", Thread.CurrentThread.Name, i);
                Thread.Sleep(300);          //休眠300毫秒                                                
            }
            Console.ReadKey();

Abort() 和 ResetAbort() 方法

Abort()方法是终止线程，ResetAbort()取消为当前线程请求的Thread.Abort()。

个人理解类似于Suspend()挂起线程和Resume()恢复被挂起的资源。但是 Suspend（）仍会锁定被持有的锁定，其他线程不能访问被锁定的资源，当试图使用锁定的资源时，就会造成死锁。所以Suspend()既然过期了，就尽量不要使用它。

            Thread thread = new Thread(ResetAbortMethod);//必须执行无返回值的方法
            thread.Name = "子线程";
            thread.Start();//是线程被安排执行
            StringBuilder threadInfo = new StringBuilder();
            threadInfo.AppendFormat(" 线程当前的执行状态：{0}", thread.IsAlive);
            threadInfo.AppendFormat("\n 线程的当前的名字：{0}", thread.Name);
            threadInfo.AppendFormat("\n 线程的当前等级：{0}", thread.Priority);
            threadInfo.AppendFormat("\n 线程当前的状态：{0}", thread.ThreadState);

            Console.WriteLine(threadInfo);
            Console.ReadKey();

上面的线程调用的是下面的方法

public static void ResetAbortMethod()
        {
            try
            {
                Console.WriteLine("我是:{0},我要终止了", Thread.CurrentThread.Name);

                //终止线程,后面的代码不会执行。(线程终止会引发异常ThreadAbortException，Thread.ResetAbort() )
                Thread.CurrentThread.Abort();
            }
            catch (ThreadAbortException ex)
            {
                Console.WriteLine("我是:{0},我又启动了", Thread.CurrentThread.Name);

                //取消为当前线程请求的 System.Threading.Thread.Abort(System.Object) ,取消后，后面的代码可以执行
                Thread.ResetAbort();
            }

            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("我是:{0},我循环了{1}次", Thread.CurrentThread.Name,i);
            }
        }

线程安全：当一个线程访问该类的某个数据时，进行数据保护，其他线程不能进行访问知道该线程读取完毕，                其他线程才可使用。不然会出现数据的不一致性。

线程是异步执行的，为此，我需要执行同步线程。就是多个线程一个一个(one by one)的执行。

Lock就可以了实现了。

摘抄内容：

lock(this) 锁定 当前实例对象，如果有多个类实例的话，lock锁定的只是当前类实例，对其它类实例无影响。所有不推荐使用。 
lock(typeof(Model))锁定的是model类的所有实例。 
lock(obj)锁定的对象是全局的私有化静态变量。外部无法对该变量进行访问。 
lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。 
所以，lock的结果好不好，还是关键看锁的谁，如果外边能对这个谁进行修改，lock就失去了作用。所以一般情况下，使用私有的、静态的并且是只读的对象。

1、lock的是必须是引用类型的对象，string类型除外。

2、lock推荐的做法是使用静态的、只读的、私有的对象。

3、保证lock的对象在外部无法修改才有意义，如果lock的对象在外部改变了，对其他线程就会畅通无阻，失去了lock的意义。

Monitor类和Mutex类 也能实现线程同步。没有去用，没具体去看。