C# 多线程学习系列二

        static void Main(string[] args)
        {
            var thread = new Thread(DoWork);
            thread.Start();
        }

        private static void DoWork()
        {
            Thread.Sleep(2000);
            Console.WriteLine("子线程处理完工作,已结束");
        }

        static void Main(string[] args)
        {
            var thread = new Thread(DoWork);
            thread.IsBackground = true;
            thread.Start();
        }

        private static void DoWork()
        {
            Thread.Sleep(2000);
            Console.WriteLine("子线程处理完工作,已结束");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("主线程开始执行,并调用了一个不带参子线程执行其他的任务");
            Thread.Sleep(500);
            var thread = new Thread(ExecuteOtherWork);//构造一个线程对象,实际没有开启线程
            thread.Start();//开启子线程,做其他的任务
            Console.WriteLine("主线程继续做它的事情");
            thread.Join();//等待不带参子线程做完它的任务
            Console.WriteLine("主线程开始执行,并调用了一个带参的子线程执行其他的任务");
            var thread1 = new Thread(ExecuteWorkWithParameter);
            thread1.Start(666);
            Console.WriteLine("主线程继续做它的事情");
            thread1.Join();
            Console.WriteLine("3个线程完美的完成了它们的任务");
            Console.Read();
        }

        /// <summary>
        /// 开启一个不传递参数的子线程,并执行它的任务
        /// </summary>
        static void ExecuteOtherWork()
        {
            Thread.Sleep(500);
            Console.WriteLine("不带参的子线程开始做它的事情,处理这件事情需要花费点时间");
            Thread.Sleep(2000);//子线程休息5秒
            Console.WriteLine("不带参的子线程完美的完成了它的任务");
            Thread.Sleep(500);
        }

        /// <summary>
        /// 开启一个带传递参数的子线程,并执行它的任务
        /// </summary>
        /// <param name="parameter"></param>
        static void ExecuteWorkWithParameter(object parameter)
        {
            Thread.Sleep(500);
            Console.WriteLine("带参的子线程开始做它的事情,处理这件事情需要花费点时间,主线程传递给它的参数是:{0}", parameter.ToString());
            Thread.Sleep(2000);//子线程休息5秒
            Console.WriteLine("带参的子线程完美的完成了它的任务");
            Thread.Sleep(500);
        }

        static void Main(string[] args)
        {
            Console.WriteLine("主线程开始执行,调用一个带参数的线程池子线程");
            //主线程调用ThreadPool.QueueUserWorkItem方法向线程池的操作队列添加一个记录项
            //线程池会遍历这个操作队列的所有记录项,然后将记录项中派发给一个线程池线程
            //接着线程池的线程就开始执行ExecuteOtherWork方法(同时接受了主线程传递给它的参数)
            ThreadPool.QueueUserWorkItem(ExecuteOtherWork,666);
            Console.WriteLine("主线程继续执行");
            Console.WriteLine("两个线程全部执行完毕");
            Console.Read();//这行代码必须加,因为线程池是后台线程,当进程关闭,该进程所有的后台线程都会被关闭,不管是否执行完毕.
        }

        /// <summary>
        /// 线程池子线程调用的方法
        /// </summary>
        /// <param name="state"></param>
        static void ExecuteOtherWork(object state)
        {
            Console.WriteLine("线程池子线程开始执行,主线程传递给它的参数是:{0}", state);
            Console.WriteLine("线程池子线程执行完毕");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("主线程开始执行,调用一个带参数的线程池子线程");
            var mainThreadContext = new HostExecutionContext("0");
            mainThreadContext=mainThreadContext.CreateCopy();
            var thread = new Thread(ExecuteOtherWork);
            thread.Start(mainThreadContext);
            Console.Read();
        }

        /// <summary>
        /// 线程池子线程调用的方法
        /// </summary>
        /// <param name="state"></param>
        static void ExecuteOtherWork(object state)
        {
            var manager = new HostExecutionContextManager();
            manager.SetHostExecutionContext(state as HostExecutionContext);
            Console.WriteLine("子线程执行完毕");
        }

        private static string shareKey = "线程之间共享的数据槽值键";
        static void Main(string[] args)
        {
            
            Console.WriteLine("主线程开始执行,调用一个带参数的线程池子线程");
            CallContext.LogicalSetData(shareKey, "666");
            ExecutionContext.SuppressFlow();
            var thread = new Thread(ExecuteOtherWork);
            thread.Start();
            Console.Read();
        }

        /// <summary>
        /// 线程池子线程调用的方法
        /// </summary>
        /// <param name="state"></param>
        static void ExecuteOtherWork(object state)
        {
            Console.WriteLine("线程之间共享的数据槽值：{0}", CallContext.LogicalGetData(shareKey));
            Console.WriteLine("子线程执行完毕");
        }

        private static string notShareContextKey = "线程内唯一的对象,无法共享到其他线程";

        private static string shareContextKey = "线程之间共享的对象,可以传播到其他线程";

        static void Main(string[] args)
        {
            Console.WriteLine("主线程开始执行,调用一个带参数的线程池子线程");
            CallContext.SetData(notShareContextKey, "111");
            CallContext.LogicalSetData(shareContextKey, "666");
            var thread = new Thread(ExecuteOtherWork);
            thread.Start();
            Console.WriteLine("看看主线程能不能通过CallContext.SetData方法拿到这个数据：{0}", CallContext.GetData(notShareContextKey) ??"没有拿到");
            Console.WriteLine("看看主线程能不能通过CallContext.LogicalSetData方法拿到主线程的逻辑上下文对象里面设置的数据：{0}", CallContext.LogicalGetData(shareContextKey) ?? "没有拿到");
            Console.Read();
        }

        /// <summary>
        /// 线程池子线程调用的方法
        /// </summary>
        /// <param name="state"></param>
        static void ExecuteOtherWork(object state)
        {
            var obj=CallContext.GetData("线程内唯一的对象,无法共享到其他线程");
            Console.WriteLine("看看子线程能不能通过CallContext.SetData方法拿到主线程的逻辑上下文对象里面设置的数据：{0}", CallContext.GetData(notShareContextKey) ?? "没有拿到");
            Console.WriteLine("看看子线程能不能通过CallContext.LogicalSetData方法拿到主线程的逻辑上下文对象里面设置的数据：{0}", CallContext.LogicalGetData(shareContextKey) ?? "没有拿到");
            Console.WriteLine("");
            Console.WriteLine("子线程执行完毕");
        }