第四十讲 感性的认识线程

主要内容
    
    1. 感性认识线程
        基本概念：
        1. 进程：当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。而一个进程又是由多个线程所组成的。
        
        2. 线程：线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针，程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。
        
        3. 多线程：多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。
        
        线程及多线程工作原理
        1. 多进程决定了操作系统的多任务。但是我们知道我们往往只有一个CPU，一个CPU在同一时间只能做一件事情，多任务又是怎么实现 的？我们知道真正完成某个任务的是线程，对于进程来讲至少会带有一个默认的线程，我们称之为主线程。我们先假设进程都带有一个线程。
        2. 线程要执行就需要CPU，我们知道现今CPU因为执行速度非常快，它没有必要单独为一个线程服务，因此它将自己一秒的时间进行切片，每片有1毫秒左右(这里只是假设，CPU速度越快切片越小)，然后它就以时间片为单位向外提供服务。比如在一秒钟内A线程占有10个时间片，B线程占有30个时间片...每一秒都这样分配了以后，操作系统负责CPU的切换，于是一秒钟过后所有线程都执行了，整体看上去好像所有的进程是在同时运行的，这就是操作系统多任务的实现方式，是通过不断切换线程执行实现的。
        
        
    2. 典型实例
    
    3. 线程的优缺点
        优点：多线程的好处是可以提高CPU的利用率。在多线程程序中，一个线程必须等待的时候，CPU可以运行其它的线程而不是等待，这样就大大提高了程序的效率。
        
        缺点：因为线程也是程序，所以线程需要占用内存，线程越多占用内存越多，多线程需要协调和管理，所以需要CPU时间跟踪线程，线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题，线程太多会导致控制太复杂，最终可能造成很多的BUG。
        
        线程的方法和状态
        Thread类有几个至关重要的方法，如下
            1. Start():启动线程
            2. Sleep(int):静态方法，暂停当前线程指定的毫秒数
            3. Abort():通常使用该方法来终止一个线程
            4. Suspent():该方法并不终止未完成的线程，它仅仅挂起线程，以后还可恢复
            5. Resume():恢复被Suspent()方法挂起的线程执行。
            
            
    4. 主线程与辅助线程
        主线程Main()函数
        1. C#支持通过多线程并行执行代码，一个线程有它独立的执行路径，能够与其它的线程同时运行。一个C#程序开始于一个单线程，这个单线程是被CLR和操作系统自动创建的(即“主线程”)。
        2. 所有线程都是依附于Main()函数所在的线程的，Main()函数是C#程序的入口，起始线程可以称之为主线程
        3. 如果所有的前台线程都停止了，那么主线程可以终止，而所有的后台线程都将无条件终止。
        4. 后台线程跟前台线程只有一个区别，那就是后台线程不妨碍程序的终止。一旦一个进程所有的前台线程都终止后，CLR(通过语言运行环境)将通过调用任意一个存活的后台进程的Abort()方法来彻底终止进程
        5. 所有的线程虽然在微观上是串行执行的，但是在宏观上你完全可以认为它们是并行执行的。
        
    5. 线程异步与线程同步
        1. 线程异步：是通过创建多个线程执行多个任务，多个工作线程同时开工，类似多辆车在宽广的公路上并行的汽车同时前进，互不干扰。
        线程都是独立的执行单元。
        它们都可以访问共享的数据--由此会产生互斥访问。
        
        2. 为了解决多线程共同访问一个共享资源时产生的并发问题，就有了线程同步的概念
        原理：就是防止多个线程同时访问某个共享资源。
        
        需要同步的资源包括：
            1. 系统资源(如通信端口)
            2. 多个进程所共享的资源(如文件句柄)
            3. 由多个线程访问的单个应用程序域的资源(如全局，静态和实例字段)
            
            线程同步是解决一个线程和另一个线程如何协调工作的技术。具体说来线程同步就是操作异步的意思，比如说，两个线程同时访问同一个资源，那么如果线程1访问时线程2停下等待，线程2访问时线程1停下等待，这就是同步。如果两个线程同时访问不分彼此，那么就是线程异步。
            
    6. 何时使用线程
        使用线程类前要事前引入空间名
        using System.Threading;
    7. 获取线程信息
    线程的状态：这个属性代表了线程运行时状态，在不同的情况下有不同的值，我们有时候可以通过对该值的判断来设计程序流程。
    ThreadState 属性的取值如下：
        1. Aborted:线程已停止
        2. AbortRequested:线程的Thread.Abort()方法已被调用，但是线程还未停止
        3. Background:线程在后台执行，与属性Thread.IsBackground有关
        4. Running:线程正在正常运行
        5. Stopped:线程已经被停止
        6. StopRequested:线程下在被要求停止
        7. Suspended:线程已经被挂起(此状态下，可以通过调用Resume()方法重新运行)
        8. SuspendRequested:线程正在被要求挂起，但是未来得及响应
        9. Unstarted:未调用Thread.Start()开始线程的运行

        10. WaitSleepJoin:线程因为调用了Wait(),Sleep()或Join()等方法处于封锁状态。

实例代码：(原模原样儿的抄写是很无聊的，我一般不会做，多多少少整点儿自己的想法进去)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Con40
{
    class Program
    {
        /// <summary>
        /// 说话的方法
        /// </summary>
        /// <param name="str"></param>
        public static void shuo(object o)//这里这个方法的参数类型是object，其它的不行，这是规定
        {
            Console.WriteLine("Hello，我是新牛出来的线程!");

            Thread tinfo2 = (Thread)o;//获取当前线程

            if (tinfo2.Name == "" || tinfo2.Name == null)
                tinfo2.Name = "第二线程";

            string threadStr = string.Format("\n当前线程的名字：{0}\n线程标识：{1}\n当前线程的区域性：{2}\n资源管理器使用的当前区域性：{3}\n上下文信息对象：{4}\n当前线程的状态：{5}\n是否为后台线程：{6}\n是否属于托管线程池：{7}\n包含的当前线程状态：{8}\n线程的优先级：{9}", tinfo2.Name, tinfo2.ManagedThreadId, tinfo2.CurrentCulture, tinfo2.CurrentUICulture, tinfo2.ExecutionContext, tinfo2.IsAlive, tinfo2.IsBackground, tinfo2.IsThreadPoolThread, tinfo2.ThreadState, tinfo2.Priority);

            Console.WriteLine(threadStr);
        }

        public static void threadStatu(object tinfo)
        {
            Console.WriteLine("我是第三个线程\n");

            Thread tinfo2 = (Thread)tinfo;//获取当前线程
            if (tinfo2.Name == "" || tinfo2.Name == null)
                tinfo2.Name = "第三线程";

            string threadStr = string.Format("\n当前线程的名字：{0}\n线程标识：{1}\n当前线程的区域性：{2}\n资源管理器使用的当前区域性：{3}\n上下文信息对象：{4}\n当前线程的状态：{5}\n是否为后台线程：{6}\n是否属于托管线程池：{7}\n包含的当前线程状态：{8}\n线程的优先级：{9}", tinfo2.Name, tinfo2.ManagedThreadId, tinfo2.CurrentCulture, tinfo2.CurrentUICulture, tinfo2.ExecutionContext, tinfo2.IsAlive, tinfo2.IsBackground, tinfo2.IsThreadPoolThread, tinfo2.ThreadState, tinfo2.Priority);

            Console.WriteLine(threadStr);
        }

        static void Main(string[] args)
        {
            Console.WriteLine("我是主线程哦！");

            //纯程信息
            Thread tinfo = Thread.CurrentThread;//获取当前线程
            if (tinfo.Name == null || tinfo.Name == "")
            {
                tinfo.Name = "主线程";
            }

            string threadStr = string.Format("\n当前线程的名字：{0}\n线程标识：{1}\n当前线程的区域性：{2}\n资源管理器使用的当前区域性：{3}\n上下文信息对象：{4}\n当前线程的状态：{5}\n是否为后台线程：{6}\n是否属于托管线程池：{7}\n包含的当前线程状态：{8}\n线程的优先级：{9}",tinfo.Name, tinfo.ManagedThreadId, tinfo.CurrentCulture, tinfo.CurrentUICulture, tinfo.ExecutionContext, tinfo.IsAlive, tinfo.IsBackground, tinfo.IsThreadPoolThread, tinfo.ThreadState, tinfo.Priority);

            Console.WriteLine(threadStr+"\n");

            Thread.Sleep(1000);

            //new一个新线程出来

            //Thread newThread = new Thread(shuo);
            //newThread.Start("Hello，我是新牛出来的线程!");

            Thread t = new Thread(shuo);
            t.Start(t);
            //t.Start(threadStr+"\n");

            Thread statu = new Thread(threadStatu);
            statu.Start(statu);



           

            Thread.Sleep(2000);
            Console.WriteLine("\n###########以下是老师讲的龟兔赛跑######################\n");

            Console.WriteLine("乌龟跑的慢，先开始跑，龟跑啊跑啊。。。跑啊。。。。。");

            //开个兔子的线程
            Thread TuZi = new Thread(TuPao);

            TuZi.Start();//在乌龟开跑的同时，兔子也应该开跑。



            for (int i = 0; i < 15; i++)
            {
                Thread.Sleep(500);//0.5秒更新一次
                Console.WriteLine("由于乌龟腿短，迈不走步子，太慢，但是它有恒心，汗流夹背的跑啊跑啊。。。跑啊。。。。。");
            }

            

            Console.ReadKey();
        }

        public static void TuPao(object o)
        {
            Thread.Sleep(500);
            Console.WriteLine("兔子两三步就赶上了乌龟。且超了过去。。。。");
            Thread.Sleep(500);
            Console.WriteLine("由于兔子步子迈的太大，一不小心扯淡了，但一想这龟太慢了，还是等等它，不要让它输的太残，顺便休息一下养养伤。。。");
            Thread.Sleep(1000);
            Console.WriteLine("一段时间过去了，兔子发现还没有看到乌龟的影子，一不小心睡了过去。。。。");
            for (int i = 0; i < 15; i++)
            {
                Thread.Sleep(400);
                Console.WriteLine("zZzzZzZzzzzzzzzzzzzzZZZZZZZZZZzzzzzzzzzzZZZZZZZ");
            }
            Console.WriteLine("兔子终于醒了，回头看看，还是没有乌龟的影子，于是它想：到终点再继续吧。。。。。");
            Thread.Sleep(1000);
            Console.WriteLine("兔子到了终点，发现其它动物都不在了，只有远处一个影子，好像乌龟。。它跑了过去。。。。");
            Thread.Sleep(1000);
            Console.WriteLine("当它走近时，发现乌龟的脖子已经挂上冠军的像征，兔子顿时吐血，它再也无颜见江东父老了。。。");
            Console.WriteLine("哈哈。。。哈哈哈。。。。。。。");

        }
    }
    
    

}

不知道我这样整的例子，你看着是不是有点头大，反正我看着有点头大。