C#多线程开发

1.进程与线程的区别

通俗的讲，进行就是任务管理器中进行列表中看到的正在运行的程序，它是一个动态的概念，活动的实体。

线程是程序执行流的最小单元，是线程中一个实体，是系统独立调度和分派CPU基本单位。

线程特点：(1).轻型实体 (2).独立调度和分派的基本单位 (3).可并发执行 (4).共享进程资源。

2.进行和线程关系：

线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；

它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。

3.线程生命状态与周期

4.线程状态

(1).新线程态：New一个线程：New Thread，这时还没有分配系统资源，只能启动或终止。

(2).可运行态(Runnable):就绪运行状态，start()方法产生运行线程所必须的资源，调度线程执行，并调用线程的Run()方法。

(3).阻塞/非运行态（Not Runnable): 当调用 挂起线程-suspend()，sleep(),wait()时处理阻塞状态。

(4).Dead状态:调用stop()方法。

5.常用线程方法

1.新建并启动线程：Thread thread1 = new Thread(new ThreadStart( Count)); count:启动多少个线程

2.杀死线程：先要通过IsAlive属性判断线程是否活着，然后再调用Abort()方法杀死线程。

3.暂停线程：thread.Sleep(1000); 就是让线程休眠1秒钟。

4.优先级：hreadPRiority属性，它用来设置优先级

一个线程的优先级可分为5种：Normal, AboveNormal, BelowNormal, Highest, Lowest。

thread.Priority = ThreadPriority.Highest;

5.挂起线程：

Thread类的Suspend方法用来挂起线程，直到调用Resume，此线程才可以继续执行。如果线程已经挂起，那就不会起作用。

if (thread.ThreadState = ThreadState.Running) 
{
     thread.Suspend();
}

6.恢复线程，也叫唤醒线程：

用来恢复已经挂起的线程，以让它继续执行，如果线程没挂起，也不会起作用。
if (thread.ThreadState = ThreadState.Suspended) 
{
    thread.Resume();
}

 6.线程的使用

线程函数通过委托传递，可以不带参数，也可以带参数（只能有一个参数），可以用一个类或结构体封装参数。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(TestMethod));
            Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
            t1.IsBackground = true; //当主线程退出的时候，IsBackground=FALSE的线程还会继续执行下去，直到线程执行结束，只有IsBackground=TRUE的线程才会随着主线程的退出而退出。
            t2.IsBackground = true;
            t1.Start();
            t2.Start("hello");
            Console.ReadKey();
        }

        public static void TestMethod()
        {
            Console.WriteLine("不带参数的线程函数");
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);
        }
    } 
}

7.线程池

当线程多的时候，如果每个线程都要创建和销毁，会对内存资源造成浪费，出于对性能的考虑，于是引入了线程池的概念。

线程池维护一个请求队列，线程池的代码从队列提取任务，然后委派给线程池的一个线程执行，线程执行完不会被立即销毁，这样既可以在后台执行任务，又可以减少线程创建和销毁所带来的开销。

线程池线程默认为后台线程（IsBackground）。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            //将工作项加入到线程池队列中，这里可以传递一个线程参数
            ThreadPool.QueueUserWorkItem(TestMethod, "Hello");
            Console.ReadKey();
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine(datastr);
        }
    }
}

8.Task类

当我们在使用线程池QueueUserWorkItem()方法执行异步执行时，无法知道操作什么时候完成的，

可以通过构造一个Task<TResult>对象，并为泛型TResult参数传递一个操作的返回类型。

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 1000);
            t.Start();
            t.Wait();
            Console.WriteLine(t.Result);
            Console.ReadKey();
        }

        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; --n)
                checked{ sum += n;} //结果太大，抛出异常
            return sum;
        }
    }
}

9.委托异步执行

委托的异步调用：BeginInvoke() 和 EndInvoke()

namespace Test
{
    public delegate string MyDelegate(object data);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate mydelegate = new MyDelegate(TestMethod);
            IAsyncResult result = mydelegate.BeginInvoke("Thread Param", TestCallback, "Callback Param");

            //异步执行完成
            string resultstr = mydelegate.EndInvoke(result);
        }

        //线程函数
        public static string TestMethod(object data)
        {
            string datastr = data as string;
            return datastr;
        }

        //异步回调函数
        public static void TestCallback(IAsyncResult data)
        {
            Console.WriteLine(data.AsyncState);
        }
    }
}

10.线程同步

1）原子操作（Interlocked）：所有方法都是执行一次原子读取或一次写入操作。

　　2）lock()语句：避免锁定public类型，否则实例将超出代码控制的范围，定义private对象来锁定。

　　3）Monitor实现线程同步

　　　　通过Monitor.Enter() 和 Monitor.Exit()实现排它锁的获取和释放，获取之后独占资源，不允许其他线程访问。

　　　　还有一个TryEnter方法，请求不到资源时不会阻塞等待，可以设置超时时间，获取不到直接返回false。

　　4）ReaderWriterLock

　　　　当对资源操作读多写少的时候，为了提高资源的利用率，让读操作锁为共享锁，多个线程可以并发读取资源，而写操作为独占锁，只允许一个线程操作。

　　5）事件（Event）类实现同步

　　　　事件类有两种状态，终止状态和非终止状态，终止状态时调用WaitOne可以请求成功，通过Set将时间状态设置为终止状态。

　　　　1）AutoResetEvent（自动重置事件）

　　　　2）ManualResetEvent（手动重置事件）

　　6）信号量（Semaphore）

　　　　　　信号量是由内核对象维护的int变量，为0时，线程阻塞，大于0时解除阻塞，当一个信号量上的等待线程解除阻塞后，信号量计数+1。

　　　　　　线程通过WaitOne将信号量减1，通过Release将信号量加1，使用很简单。

　　7）互斥体（Mutex）

　　　　　　独占资源，用法与Semaphore相似。

 　 8）跨进程间的同步

　　　　　　通过设置同步对象的名称就可以实现系统级的同步，不同应用程序通过同步对象的名称识别不同同步对象。