(29)C#多线程

使用线程的原因

1.不希望用户界面停止响应。

2.所有需要等待的操作，如文件、数据库或网络访问需要一定的时间。

一个进程的多个线程可以同时运行不同cpu或多核cpu的不同内核上

注意多线程访问相同的数据必须实现同步机制

编写能够利用并行性的代码需要区分两种场景：任务并行性和数据并行性

任务并行性：使用CPU的代码被并行化，利用cpu的多个核心快速的完成包含多个任务的活动。

数据并行性：使用了数据集合，在集合上执行的工作被划分为多个任务。

任务并行性和数据并行性可以混合起来。

Parallel类（自 4.0 起可用）

Parallel类定义了并行的for和foreach的静态方法，使用多线程来完成作业。

Parallel.For()和Parallel.ForEach()方法再每次迭代中调用相同的代码。而Parallel.Invoke()方法允许同时调用不同的方法。

Parallel.Invoke()用于任务并行性，Parallel.Invoke()用于数据并行性。

Parallel.For()

using System.Threading;
using System.Threading.Tasks;

    class Program
    {     
        static void Main(string[] args)
        {
 
            //参数1 int ，参数2 int，参数3 action<int>
            Parallel.For(3, 10, (i)=> {
                Console.WriteLine("id:" + i + "   thread:" + Thread.CurrentThread.ManagedThreadId);
            });
            Console.WriteLine("end");
            Console.ReadLine();
        }
    }

参数3的action中可以添加一个控制状态的类型

Action<Int32,ParallelLoopState>)

使用 Break()和Stop()尽早的结束循环，在结束前启动的线程仍可以继续执行。

Break() 尽早结束当前以外的线程

Stop() 尽早结束

    class Program
    {     
        static void Main(string[] args)
        {
            
            Parallel.For(3, 100000, (i, state) => {
                if (i > 6)
                {
                    state.Stop();
                    Console.WriteLine("abc");
                }
                Console.WriteLine("id:" + i + "   thread:" + Thread.CurrentThread.ManagedThreadId);
            });
            Console.WriteLine("end");
            Console.ReadLine();
        }
    }

Parallel.ForEach()

用来遍历一个能被迭代的集合，相当于一个多线程的foreach版

    class Program
    {     
        static void Main(string[] args)
        {
            int[] count = { 2, 3, 6, 4, 7, 25, 42, 612, 12 };
            Parallel.ForEach(count, (i, state) => {
   
                Console.WriteLine("id:" + i + "   thread:" + Thread.CurrentThread.ManagedThreadId);
            });
            Console.WriteLine("end");
            Console.ReadLine();
        }
    }

Parallel类返回类型

Parallel.for 和 Parallel.foreach 返回 ParallelLoopResult 类型，用来判断是否执行完成

    class Program
    {
        static void Main(string[] args)
        {
            ParallelLoopResult res = Parallel.For(3, 10, (i, state) => {
                Console.WriteLine("id:" + i + "   thread:" + Thread.CurrentThread.ManagedThreadId);
            });
            Console.WriteLine(res.IsCompleted);
            Console.ReadLine();
        }
    }

 

Parallel.Invoke()

public static void Invoke (params Action[] actions) ,可以调用多个不同的方法

    class Program
    {
        static void Main(string[] args)
        {
            Parallel.Invoke(a,b);
            Console.WriteLine("end");
            Console.ReadLine();
        }

        static public void a()
        {
            Console.WriteLine("a");
        }
        static public void b()
        {
            Console.WriteLine("b");
        }
    }

 任务

 1.工厂类的方式启动一个线程

        static void Main(string[] args)
        {
            var tf = new TaskFactory();
            Task task = tf.StartNew(abc);
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

        static public void abc()
        {
            Console.WriteLine("abc:"+ Thread.CurrentThread.ManagedThreadId);
        }

 

2.Task的静态Factory属性启动线程

        static void Main(string[] args)
        {
    
            Task task = Task.Factory.StartNew(abc);
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

3.使用Task的构造函数

 实例化后不会立即启动线程，当对象调用Start()方法时才开始启动

        static void Main(string[] args)
        {
    
            Task task =new Task(abc);
            task.Start();
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

 4.使用Task的静态Run方法

        static void Main(string[] args)
        {
            Task task =Task.Run(abc);
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

5.使用Task同步运行

        static void Main(string[] args)
        {
            Task task =new Task(abc);
            task.RunSynchronously();
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

6.使用单独的线程，而不是线程池

        static void Main(string[] args)
        {
            Task task =new Task(abc,TaskCreationOptions.LongRunning);
            task.Start();
            Console.WriteLine("main:"+Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }

7.带返回值的任务

  Func<>   返回Task<TResult>

        static void Main(string[] args)
        {
            Task<int> task =Task<int>.Run(()=>{
                Console.WriteLine("111");
                return 5;
            });
            Console.WriteLine(task.Result);
            Console.WriteLine("abc");
            Console.ReadLine();
        }

task.Result会等到Task执行完才会被调用相当于调用的wait，所以abc会在结果打印之后再打印

8.连续的任务

 ContinueWith

        static void Main(string[] args)
        {
            Task task1 = new Task(a);
            Task task2 = task1.ContinueWith(b);
            Task task3 = task2.ContinueWith(c);
            task1.Start();
            Console.WriteLine("end");
            Console.ReadLine();
        }

        static public void a()
        {
            Console.WriteLine("a:" + Thread.CurrentThread.ManagedThreadId);
        }

        static public void b(Task t)
        {
            Console.WriteLine("b:" + Thread.CurrentThread.ManagedThreadId);
        }

        static public void c(Task t)
        {
            Console.WriteLine("c:" + Thread.CurrentThread.ManagedThreadId);
        }

 

9.连续任务控制

使用TaskContinuationOptions的枚举成员，上一步出现某种问题时，来确定是否执行现在的方法

        static void Main(string[] args)
        {
            Task task1 = new Task(a);
            Task task2 = task1.ContinueWith(b,TaskContinuationOptions.DenyChildAttach);
            task1.Start();
            Console.WriteLine("end");
            Console.ReadLine();
        }

 10.任务的层次

11.

 ----------------------------------

Thread类

    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(M);
            t1.Start();
            //Thread.Sleep(1000);
            Console.WriteLine("BBB");
            Console.ReadKey();
        }

        static void M()
        {
           
            Console.WriteLine("AAA");
        }
    }

先输出AAA，还是BBB取决于操作系统调度

委托方式，输出结果和上列子相同

    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(() => Console.WriteLine("AAA"));
            t1.Start();
            Thread.Sleep(1000);
            Console.WriteLine("BBB");
            Console.ReadKey();
        }
    }

给线程传递数据

 方法一，启动线程时传递参数

    class Program
    {
        static void Main(string[] args)
        {
            C c = new C { Message="hello" };
            Thread t = new Thread(ThreadM);
            t.Start(c);//线程启动时传参
            Console.ReadKey();
        }

        static void ThreadM(object O)
        {
            C c = (C)O;
            Console.WriteLine("AAA:{0}",c.Message);
        }
    }
    public class C
    {
        public string Message;
    }

方法二、自定义类

    class Program
    {
        static void Main(string[] args)
        {
            C c = new C ("hello");
            Thread t = new Thread(c.ThreadMain);
            t.Start();
            Console.ReadKey();
        }
    }
    public class C
    {
        public string Message;
        //构造函数
        public C(string Message)
        {
            this.Message = Message;
        }

        public void ThreadMain()
        {
            Console.WriteLine("AAA:{0}",Message);
        }
    }

后台线程

前台线程可以有多个，后台线程也可以有多个。只要有一个前台线程在运行，程序的Main方法就不算结束。

Thread类创建的是前台线程。线城池中的线程时后台线程。

        static void Main(string[] args)
        {
            //IsBackground默认为false,表示为前台线程
            Thread t = new Thread(ThreadMain) { Name="线程",IsBackground=false};
            t.Start();
            Console.WriteLine("AAA");
            Console.ReadKey();
        }


        public static void ThreadMain()
        {
            Console.WriteLine("{0}启动",Thread.CurrentThread.Name);
            Thread.Sleep(6000);
        }
    }

如果IsBackground=false，按任意键后，会等执行完sleep方法才会结束。

如果IsBackground=true，按任意键后会立即结束。

这说明，如果有一个前台线程没执行完，Main方法就算都执行完，也要等到前台程序执行完才算是结束。

线程优先级

 线程的priority属性可以控制线程的优先级

它是一个枚举类型

Highest > AboveNormal > Normal > BelowNormal > Lowest

    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(ThreadMain) { Name = "A", Priority = ThreadPriority.Lowest };
            Thread t2 = new Thread(ThreadMain) { Name = "B", Priority = ThreadPriority.Highest };
            Thread t3 = new Thread(ThreadMain) { Name = "C", Priority = ThreadPriority.Normal };
            t1.Start();
            t2.Start();
            t3.Start();
            Console.ReadKey();
        }
        public static void ThreadMain()
        {
            Thread.Sleep(1000);
            for (int i = 0; i < 5000; i++)
            {
                Console.Write("{0}", Thread.CurrentThread.Name);
            }
        }
    }

线程优先级高的占用的CPU会更多一些

线程问题

争用条件

如果两个或多个线程访问相同的对象，并且对共享状态的访问没有同步，就会出现争用条件。

解决办法：加一个lock锁，只能锁引用类型

    class Program
    {
      static  object o = new object();
        static void Main(string[] args)
        {

        }
        public static void a()
        {
            lock (Program.o)
            {
                .....
            }
        }
    }

死锁

锁定过多可能会引发死锁问题

同步