static object taskMethodLock = new object();

         static void TaskMethod(object title)

         {

             lock (taskMethodLock)

             {

                 Console.WriteLine(title);

                 Console.WriteLine("Task id: {0}, thread: {1}",

                   Task.CurrentId == null ? "no task" : Task.CurrentId.ToString(),

                   Thread.CurrentThread.ManagedThreadId);

                 Console.WriteLine("is pooled thread: {0}", Thread.CurrentThread.IsThreadPoolThread);

                 Console.WriteLine("is background thread: {0}", Thread.CurrentThread.IsBackground);

                 Console.WriteLine();

             }

         }

 　　　　　　　var tf = new TaskFactory();

             Task t1 = tf.StartNew(TaskMethod, "using a task factory");

             Task t2 = Task.Factory.StartNew(TaskMethod, "factory via a task");

             var t3 = new Task(TaskMethod, "using a task constructor and Start");

             t3.Start();

             Task t4 = Task.Run(() => TaskMethod("using the Run method"));

           TaskMethod("just the main thread");

            var t1 = new Task(TaskMethod, "run sync");

            t1.RunSynchronously();    

        var t1 = new Task(TaskMethod, "long running",TaskCreationOptions.LongRunning);

            t1.Start();

   static void ResultsFromTasks()

         {

             var t1 = new Task<Tuple<int, int>>(TaskWithResult, Tuple.Create<int, int>(, ));

             t1.Start();

             Console.WriteLine(t1.Result);

             t1.Wait();

             Console.WriteLine("result from task: {0} {1}", t1.Result.Item1, t1.Result.Item2);

         }

         static Tuple<int, int> TaskWithResult(object division)

         {

             Tuple<int, int> div = (Tuple<int, int>)division;

             int result = div.Item1 / div.Item2;

             int reminder = div.Item1 % div.Item2;

             Console.WriteLine("task creates a result ...");

             return Tuple.Create<int, int>(result, reminder);

         }

  static void ContinuationTask()

         {

             Task t1 = new Task(DoOnFirst);

             Task t2 = t1.ContinueWith(DoOnSecond);

             Task t3 = t1.ContinueWith(DoOnSecond);

             Task t4 = t1.ContinueWith(DoOnSecond);

             Task t5 = t1.ContinueWith(DoOnError, TaskContinuationOptions.OnlyOnFaulted);

             t1.Start();

             Thread.Sleep();

         }

         static void DoOnFirst()

         {

             Console.WriteLine("doing some task {0}", Task.CurrentId);

             Thread.Sleep();

         }

         static void DoOnSecond(Task t)

         {

             Console.WriteLine("task {0} finished", t.Id);

             Console.WriteLine("this task id {0}", Task.CurrentId);

             Console.WriteLine("do some cleanup");

             Thread.Sleep();

         }

         static void DoOnError(Task t)

         {

             Console.WriteLine("task {0} had an error!", t.Id);

             Console.WriteLine("my id {0}", Task.CurrentId);

             Console.WriteLine("do some cleanup");

         } 

         static void ParentAndChild()

         {

             var parent = new Task(ParentTask);

             parent.Start();

             Thread.Sleep();

             Console.WriteLine(parent.Status);

             Thread.Sleep();

             Console.WriteLine(parent.Status);

         }

         static void ParentTask()

         {

             Console.WriteLine("task id {0}", Task.CurrentId);

             var child = new Task(ChildTask); // , TaskCreationOptions.DetachedFromParent);

             child.Start();

             Thread.Sleep();

             Console.WriteLine("parent started child");

             // Thread.Sleep(3000);

         }

         static void ChildTask()

         {

             // Console.WriteLine("task id {0}, parent: {1}", Task.Current.Id, Task.Current.Parent.Id);

             Console.WriteLine("child");

             Thread.Sleep();

             Console.WriteLine("child finished");

         }