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)跨进程间的同步

      通过设置同步对象的名称就可以实现系统级的同步,不同应用程序通过同步对象的名称识别不同同步对象。
原文地址:https://www.cnblogs.com/flyerca/p/5387086.html