发布：2019/8/1 8:45:39作者：管理员 来源：本站 浏览次数：995

1.通过任务开启线程
1.1 创建Task对象

      首先创建任务对象，任务对象调用Start()方法开启任务线程。

    class Program
    {
        static void DownLoad(object str)
        {
            Console.WriteLine("DownLoad Begin ID = " + Thread.CurrentThread.ManagedThreadId + " " + str);
            Thread.Sleep(1000);
            Console.WriteLine("DownLoad End");
        }
        static void Main(string[] args)
        {
            //创建任务
            Task task = new Task(DownLoad, "人民日报");
            //启动任务
            task.Start();
            Console.WriteLine("Main");   
            Console.ReadKey();
        }
    }

运行结果

1.2 任务工厂TaskFactory

      首先创建任务工厂，然后调用StartNew()方法开启任务线程。

    class Program
    {
        static void DownLoad(object str)
        {
            Console.WriteLine("DownLoad Begin ID = " + Thread.CurrentThread.ManagedThreadId + " " + str);
            Thread.Sleep(1000);
            Console.WriteLine("DownLoad End");
        }
        static void Main(string[] args)
        {
            //创建任务工厂
            TaskFactory taskFactory = new TaskFactory();
            //开始新的任务
            taskFactory.StartNew(DownLoad, "纽约时报");
            Console.WriteLine("Main");
            Console.ReadKey();
        }
    }

运行结果

2.连续任务

     如果一个任务的执行依赖于另一个任务，即任务的执行有先后顺序。此时，我们可以使用连续任务。

    task.ContinueWith(ReadNews)表示一个任务task结束后，才开始执行另一个任务。

    class Program
    {
        static void DownLoad(object str)
        {
            Console.WriteLine("DownLoad Begin ID = " + Thread.CurrentThread.ManagedThreadId + " " + str);
            Thread.Sleep(1000);
            Console.WriteLine("DownLoad End");
        }
        static void ReadNews(Task obj)
        {
            Thread.Sleep(1000);
            Console.WriteLine("Read News");
        }
        static void Main(string[] args)
        {
            Task task = new Task(DownLoad, "人民日报");
            Task task2 = task.ContinueWith(ReadNews);
            task.Start();
            Console.ReadKey();
        }
    }

执行结果

3.任务的层次结构

   在一个任务中可以启动子任务，两个任务异步执行。默认情况下，子任务（即由外部任务创建的内部任务）将独立于其父任务执行。使用TaskCreationOptions.AttachedToParent显式指定将任务附加到任务层次结构中的某个父级。

   如果父任务执行完了但是子任务没有执行完，则父任务的状态会被设置为WaitingForChildrenToComplete,只有子任务也执行完了，父任务的状态才会变成RunToCompletion。

    class Program
    {
        static void DownLoad(object str)
        {
            Console.WriteLine("Parent Begin ID = " + Thread.CurrentThread.ManagedThreadId + " " + str);
     
            Task child = new Task(ChildWork, TaskCreationOptions.AttachedToParent);
            child.Start();
            Thread.Sleep(1000);
            Console.WriteLine("Parent End");
        }
     
        static void ChildWork()
        {
            Console.WriteLine("Child begin");
            Thread.Sleep(5000);
            Console.WriteLine("Child end");
        }
     
        static void Main(string[] args)
        {
            Task task = new Task(DownLoad, "人民日报");
            task.Start();
            Thread.Sleep(2000);
            Console.WriteLine(task.Status);
            Thread.Sleep(4000);
            Console.WriteLine(task.Status);
            Console.ReadKey();
        }
    }

  运行结果：

 
4.任务的执行结果

    使用Task的泛型版本，可以返回任务的执行结果。

    下面例子中的TaskWithResult的输入为object类型，返回一个元组Tuple<int, int>。

     定义调用TaskWithResult的任务时，使用泛型类Task<Tuple<int, int>>，泛型的参数定义了返回类型。通过构造函数，传递TaskWithResult，构造函数的第二个参数定义了TaskWithResult的输入值。

     任务完成后，通过Result属性获取任务的结果。

    class Program
    {
        static Tuple<int, int> TaskWithResult(object obj)
        {
            Tuple<int, int> div = (Tuple<int, int>)obj;
            Thread.Sleep(1000);
            return Tuple.Create<int, int>(div.Item1 + div.Item2, div.Item1 - div.Item2);
        }
        static void Main(string[] args)
        {
            var task = new Task<Tuple<int, int>>(TaskWithResult, Tuple.Create<int, int>(8, 3));            
            task.Start();
            Console.WriteLine(task.Result);
            task.Wait();
            Console.WriteLine("Result: {0} {1}", task.Result.Item1, task.Result.Item2);
            Console.ReadLine();
        }
    }

    执行结果：