整理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类 也能实现线程同步。没有去用，没具体去看。