zoukankan      html  css  js  c++  java
  • C#多线程学习一

    一、概述:C#支持多线程并行执行程序,一个线程有他单独的执行路径,能够与其他线程同时执行,一个程序是由一个单线程开始,该单线程由CLR(公共语言运行时)和操作系统创建而成,并具有多线程创建额外线程的功能。

    1、创建线程的方法

    <1>、通过Thread类来创建线程,ThreadStart委托创建线程从哪里开始运行的方法

    using System;
    using System.Threading;
    namespace Mulithreading{
        class CreateThreadMethods{
            static void Main(string[] args){
                 ThreadStart ts=new ThreadStart(Run);//创建指定线程从哪里(哪个方法)开始的委托
                 Thread th=new Thread(ts);//传入指定的委托,创建线程实例
                 th.Start();//开始线程
                 
            }
            static void Run(){
    
           }
        }
    }

    <2>第二种方式:通过C#语法糖来创建线程,直接给Thread类传递方法,这个方法会被编译器自动推断出来,也就是说只要传递给Thread类的方法符合ThreadStart委托所定义的方法格式,那么这个方法会被编译器自动编译成ThreadStart委托

    using System;
    using System.Threading;
    namespace Mulithreading{
        class CreateThreadMethods{
            static void Main(string[] args){
            Thread th=new Thread(Run);
            th.Start();
             }
             static void Run(){
              }
        }
    }

    <3>第三种方式:采用匿名委托的方式,创建线程

    static void Main() {
      Thread t = new Thread (delegate() { Console.WriteLine ("Hello!"); });
      t.Start();
    }

    2、创建线程前需要注意的事项

    <1>、线程有一个IsAlive属性,在调用Start()之后直到线程结束之前一直为true。一个线程一旦结束便不能重新开始了。

    二、实例

    1、主线程和子线程分别执行不同的任务

    using System;
    using System.Threading;
    namespace MuliThreading
    {
        class Thread1
        {
            static void Main(string[] args)
            {
                Thread t = new Thread(writeY);   //为该类传入一个方法(委托)
                t.Start();
                while (true) Console.Write("x");
            }
            static void writeY()
            {
                while (true) Console.Write("y");
            }
    
            //代码解读:主线程创建了一个新线程t,t传入的是writeY方法,重复打印y,同时主线程打印x,主线程和新线程同时执行
            
        }
    }

    输出结果:

    无限输出x和y;

    2、主线程和子线程分别执行相同的任务

    using System;
    using System.Threading;
    
    namespace Mulithreading
    {
        class Thread2
        {
            static void Main(string[] args) {
                new Thread(Go).Start();
                Go();
            }
            static void Go() {
                for (int i = 0; i < 5; i++) {
                    Console.Write("?");
                }
            }
            //代码解读:在主线程中创建了一个子线程,主线程和子线程同时执行Go()
        }
    }

    输出:

    3、主线程和子线程使用同一目标的公共实例

    using System;
    using System.Threading;
    
    namespace Mulithreading
    {
        class Thread3
        {
            bool done;
            static void Main(string[] args)
            {
                Thread3 t3 = new Thread3();
                Thread t = new Thread(t3.Go);
                t.Start();
                t3.Go();
    
            }
            void Go() {
                if (!done) { done = true; Console.Write("done"); }
            }
    
            //代码解读:主线程Main()方法和在其中定义的子线程所调用的GO()方法共享以一个公共属性done,当吊用子线程时,对done的修改会影响到主线程的使用,因为两个线程在理论上讲是同时执行,但是实际上不可能精确的同时执行,所以当主线程吊用Go()方法是done为true
        }
    }

    输出:done

    4、主线程和子线程使用同一目标属性可能会出现的问题

    using System;
    using System.Threading;
    namespace Mulithreading
    {
        class Thread4
        {
            bool done;
            static void Main(string[] args)
            {
                Thread4 t4 = new Thread4();
                new Thread(t4.Go).Start();
                t4.Go();
            }
            void Go()
            {
                if (!done) { Console.Write("done"); done = true; }
            }
            //代码解读:当在主线程中吊用子线程时,注意两个线程是同时进行的,所以当子线程吊用Go()方法并执行时,主线程也同时进行吊用执行,两个线程是并行的,所以他们同时输出了done
        }
    }

    输出:done  done

     5、线程间共用同一静态变量产生的"线程安全问题"

    using System;
    using System.Threading;
    
    namespace Mulithreading
    {
        class Thread5
        {    
            //静态字段提供了另一种线程间共享数据的方法
            static bool done;
            static void Main(string[] args)
            {
                new Thread(Go).Start();
                Go();
            }
            static void Go() {
                if (!done) { done = true; Console.Write("done"); }
            }
            //代码解读:这个demo充分的说明了一个潜在的问题,"线程安全问题",从这这列子中看就是,无法确定输出的结果,有可能是输出两个"done"(虽然可能性不大),但是如果调正代码如下
            //static void Go(){
                 //if(!done){Console.Write("done");done=true;}
            //}
            //这样打印两次done的概率就大大增大了
    
        }
    }

    输出:done

    6、使用排他锁(locker)解决线程安全问题

        使用场景:在多线程编程中,会有多个线程并发吊用同一个代码块A的情况,用来提升代码的执行效率。在某些情况下,我们可能需要在执行代码块A的同时,同步地执行代码块B。即同一个时间段只有一个线程执行代码块B,这个时候就需要用到排他锁(lock),lock能确保代码块B完成运行的同时,保证不会被其他线程所干扰或中断。它可以把一段代码定义成为互斥段,互斥段在一个时刻内只允许一个线程进入,其他线程必须等待,下面是实例代码:

    using System;
    using System.Threading;
    namespace Mulithreading
    {
        class Thread6
        {
            static bool done;
            static Object locker = new Object();
            static void Main(string[] args)
            {
                new Thread(Go).Start();
                Go();
            }
            static void Go()
            {
                lock (locker)
                {
                    if (!done) { Console.Write("done"); done = true; }
                }
            }
        }
    }

    注意:

    1、lock语句中的表达式一定要是引用类型的表达式,编译器永远不会为lock内的语句进行隐式装箱转换,当lock内的语句为值类型而不是引用类型时,则会报一个编译错误;

    2、常用的引用类型有:类、接口、委托、字符串、object、数组。但是最好不要锁定字符串,因为使用lock进行同步时,要保证lock的是同一个对象,当我们对lock的字符串进行赋值(修改)是,实际上是创建了一个新的对象,这样多个线程以及每个循环之间所lock的对象都不同,这样达不到同步的效果,常用的方法是,new  一个Object,并且永不修改他。

    using System;
    using System.Threading;
    
    namespace Mulithreading
    {
        class CastCoin
        {
            static Object locker = new Object();
            public static int donationNums = 0;
            static void Main(string[] args) {
                new Thread(Write).Start();//先进
                new Thread(Write).Start();//后进
            }
            static void Write() {
                while (true)
                {
                    lock (locker)
                    {
                        donationNums += 100;
                        Console.WriteLine("当前有人正在捐款......请稍等");
                        Thread.Sleep(3000);
                        Console.WriteLine("到目前为止,共募捐{0}元", donationNums);
                    }
                }
            }
        }
    }

     代码解读:上面代码加了lock之后,一次只允许一个线程进入,所以输出结果如下图:

    如果不加lock,结果如下图:

    分析:两个线程同时执行累加100的操作,所以当输出总金额的时候,两个线程都执行完了累加100的操作,所以两个线程都输出200......以此类推;

    7、使用Join方法,阻塞调用线程,直到子线程终止或者到一定的时间为止

    Join一共有三个重载方法

     public void Join();
     public bool Join(int millisecondsTimeout);
     public bool Join(TimeSpan timeout);

    相信理解了一个,其他的就迎刃而解了。

    首先说Join()方法,他是Thread类的一个实例方法,可惜的是我大MSDN对于Join()的注释也太简单了,下面的英文有看不懂,所以只能去问度娘了.

    MSDN:在继续执行标准的 COM 和 SendMessage 消息泵处理期间,阻止调用线程,直到由该实例表示的线程终止。

    度娘:直接上代码

    using System;
    using System.Threading;
    using System.Diagnostics;
    namespace Mulithreading{
        class Thread_Join{
        static void Main(string[] args){
              Stopwatch sw=Stopwatch.StartNew();    
               Thread[] ths=new Thread[5];
                Array.ForEach<Thread>(ths,t=>{
                       t=new Thread(new ThreadStart(Run));//开启一个新的时间间隔实例
                       t.Start();
                       t.Join();//阻塞主线程,直到线程数组执行完毕才会执行主线程中的方法
                });
                Console.Write("总共花费时间:{0}",sw.Elapsed);
           }
           static void Run(){
                Thread.Sleep(1000);
           }    
        }
    }

    输出:

    推论:根据结果可以推断线程数组依次去执行Run()方法,如果不是依次,那么输出结果就会是1秒。而且t.Join让子线程依次执行Run()方法的同时,也阻塞了主线程。

    综上所述:也就是主线程执行子线程数组,子线程数组在Join()方法的影响下,子线程数组中的子线程不会并发的一次性全部执行完毕,而是一个个依次执行,而主线程(这里是Main()方法),只有当子线程数组全部执行完毕,才会执行主线程中的方法;

    下面我们通过代码来证明这一推论:

    using System;
    using System.Threading;
    using System.Diagnostics;
    namespace Mulithreading
    {
        class Thread_Join
        {
            static void Main(string[] args)
            {
                Stopwatch sw = Stopwatch.StartNew();
                Thread[] ths = new Thread[5];
                int i = 0;
                Array.ForEach<Thread>(ths, t =>
                {
                    t = new Thread(new ThreadStart(Run));
                    t.Start();
                    i++;
                    t.Name = "线程" + i;  //给当前线程命名
                    t.Join();
                });
                Console.WriteLine("总共花费时间:{0}", sw.Elapsed);
                sw.Stop();
            }
            static void Run()
            {
                Thread.Sleep(1000);
                Console.WriteLine("当前正在执行的线程:{0}", Thread.CurrentThread.Name);//输出正在执行该方法的线程名
            }
        }
    }

    通过给线程命名的方式,证明了我们的推论是正确的;

    8、通过ParameterizedThreadStart委托给线程调用的方法传递参数来区分线程

    using System;
    using System.Threading;
    
    namespace Mulithreading
    {
        class ParameterizedThreadStart_Study
        {
            static object locker = new object();
            static void Main() { 
               //由于ThreadStart只能接收无参数无返回值的方法,但是有些时候我们需要为线程吊用的方法传递对象,这个时候ThreadStart就无法完成这个工作
               //所幸的是.Net Framework定义了另一个版本的委托叫做PatameterizedThreadStart,单从字面上看它的意思是:参数化的ThreadStart,它可以接收一个Object作为参数
    
                ParameterizedThreadStart pt = new ParameterizedThreadStart(Run);//ParameterizedThreadStart接收一个方法(该方法无返回值,接收一个Object作为参数)
                Thread th = new Thread(pt);
                th.Start(true);
                Run(false);
                
            }
            static void Run(object obj){
                lock (locker)
                {
                    if (obj != null)
                        Console.WriteLine((bool)obj == true ? "hello" : "HELLO");
                    else
                        Console.WriteLine("Run方法需要一个object参数");
                }
            }
        }
    }
  • 相关阅读:
    android开发我的新浪微博客户端登录页面UI篇(4.1)
    android开发我的新浪微博客户端用户授权页面UI篇(3.1)
    js操作select相关方法(收集)
    C# 位操作
    用c#创建支持多语言的WinForm应用程序
    简单的Android对文件进行读写操作
    nginx 安装+反向代理设置
    安装APK文件到Android模拟器
    浅谈C# Socket编程及C#如何使用多线程
    iPhone 动画效果类型
  • 原文地址:https://www.cnblogs.com/GreenLeaves/p/6340960.html
Copyright © 2011-2022 走看看