多线程基础知识（一）

基础知识

1） 一个应用程序就是一个进程，一个进程中至少有一个线程，线程可分为前台线程和后台线程。

2） 前台线程和后台线程

3） 一个人一边烧水一边洗衣服比“先烧水再洗衣服”效率高。同一时刻一个人只能干一件事情，其实是在“快速频繁切换”，如果处理不当可能比不用多线程效率还低。讨论多线程先只考虑“单核 cpu”。

4） 普通的代码是从上向下执行的，但是多线程的代码可以“并行”执行，可以把“线程”理解成独立的执行单元，线程中的代码可以“并行执行”。

　　线程根据情况被分配给一定的“时间片”来运行，可能一个线程还没执行完，就又要把时间片交给别的线程执行。把要在单独的线程放到一个方法中，然后创建 Thread 对象，运行它，这个 Thread中的代码就会在单独的线程中执行。

5） 多线程的好处：

　　　　有很大可能增加系统的运行效率；

　　　　开发 winform 程序，避免界面卡；

　　　　注册后向用户发送欢迎邮件，如果发送邮件很慢的话，避免注册过程很慢

static void Main(string[] args)
        {
            
            int i = 5;
            //创建一个子线程
            Thread t1 = new Thread(() =>
            {
                //返回到主线程中
                Console.WriteLine("i="+i);
            });
            t1.Start();
            Console.ReadLine();
        }

参数化线程

static void Main(string[] args)
        {
            
            int i = 5;
            //创建一个子线程
            Thread t1 = new Thread((obj) =>
            {//委托中添加参数
                //返回到主线程中
                Console.WriteLine("i=" + i);
                Console.WriteLine("obj="+ obj);
            });
            //参数化
            t1.Start(i);
            Console.ReadLine();
        }

创建的十个线程执行的顺序是不一定的，所以出现这样的结果

线程睡眠

Thread.Sleep(n)指当前代码所在的线程“睡眠 N 毫秒”

线程退出

前后台线程的主要区别：

　　　　进程中只要存在没有完成的前台线程，进程就不会被销毁。

　　　　换句话说就是，如果所有的前台线程都完成了，进程就会被销毁，即使是存在未完成任务的后台线程。

　　　　可以通过设置Thread.IsBackground来把线程设置为前台线程或者是后台线程。

　　　　把线程设置为“后台线程”后，所有“非后台线程”执行结束后程序就会退出，不会等“后台线程”执行结束

线程优先级

 static void Main(string[] args)
        {
            Thread t1 = new Thread(()=> {
                Console.WriteLine("线程优先级");
            });
            //设置线程优先级，线程默认都是Normal级
            t1.Priority = ThreadPriority.Normal;
            t1.Start();
        }


public enum ThreadPriority
    {
        Lowest = 0,
        BelowNormal = 1,
        Normal = 2,
        AboveNormal = 3,
        Highest = 4
    }

线程的终止

　　可以调用 Thread 的 Abort 方法终止线程的执行，会在当前执行的代码上“无风起浪”的抛出 ThreadAbortException，可以 catch 一下验证一下，一般不需要程序去 catch。

线程的同步

class Program
    {
        private static int counter = 0;
        static void Main(string[] args)
        {
            Thread t1 = new Thread(() =>
            {
                for (int i = 0; i < 1000; i++)
                {
                    counter++;
                    Thread.Sleep(1);
                }
            });
            t1.Start();
            Thread t2 = new Thread(() =>
            {
                for (int i = 0; i < 1000; i++)
                {
                    counter++;
                    Thread.Sleep(1);
                }
            });

            t2.Start();
            while (t1.IsAlive) { };
            while (t2.IsAlive) { };
            Console.WriteLine(counter);
            Console.ReadKey();
        }

    }

当t1线程占用counter时t2线程可能已经改变了counter的值，造成数据的不同步

　　解决方案：

①：lock关键字：对象互斥
②：[MethodImpl(MethodImplOptions.Synchronized)],只能有一个线程访问
③：Monitor类：lock关键字最终会被编译成Monitor

class Program
    {
        private static int counter = 0;
        private static object locker = new object();
        static void Main(string[] args)
        {
            Thread t1 = new Thread(() =>
            {
                for (int i = 0; i < 1000; i++)
                {
                    lock (locker)
                    {
                        counter++;
                    }
                    Thread.Sleep(1);
                }
            });
            t1.Start();
            Thread t2 = new Thread(() =>
            {
                for (int i = 0; i < 1000; i++)
                {
                    lock (locker) { 
                        counter++;
                    }
                    Thread.Sleep(1);
                }
            });

            t2.Start();
            while (t1.IsAlive) { };
            while (t2.IsAlive) { };
            Console.WriteLine(counter);
            Console.ReadKey();
        }
    }

线程中其它的操作

1、Interrupt 用于提前唤醒一个在 Sleep 的线程，Sleep 方法会抛出 ThreadInterruptedException 异常

Thread t1 = new Thread(()=> {
 Console.WriteLine("t1要睡了");
 try
 {
 Thread.Sleep(5000);
 }
 catch(ThreadInterruptedException)
 {
 Console.WriteLine("擦，叫醒我干啥");
 }
 Console.WriteLine("t1醒了");
 });
 t1.Start();
 Thread.Sleep(1000);
 t1.Interrupt();

2、Sleep 是静态方法，只能是自己主动要求睡，别人不能命令他睡

3、已经过时的方法：Suspend、Resume。不要用

4、Abort()方法会强行终止线程，会引发线程内当前在执行的代码发出 ThreadAbortException异常

5、t1.Join()当前线程等待 t1 线程执行结束（Join 这里翻译成“连接”：你完了我再接着）

class Program
    {
        
        static void Main(string[] args)
        {
            Thread t1 = new Thread(() =>
            {
                for (int i = 0; i < 100; i++)
                {
                    Console.WriteLine("t1 " + i);
                }
            });
            t1.Start();
            Thread t2 = new Thread(() =>
            {
                t1.Join();//等着 t1 执行结束
                for (int i = 0; i < 100; i++)
                {
                    Console.WriteLine("t2 " + i);
                }
            });
            t2.Start();
        }
    }

单例模式与多线程

简单实用的，可在单线程也可在多线程中使用：

class God{
    private static God instance=new God();
    private God(){
    
    }
    public static God GetInstance(){
        return instance;
    }
}

懒汉模式：他的问题在于如果是多线程则可能有2个线程同时访问if(instance==null)，则会出现问题

class God{
    private static God instance=null;
    private God(){}
    
    public static God GetInstance(){
        if(instance==null){
            instance=new God();
        }
        return instance;
    }
}

多线程下的懒汉模式：这种情况在每次创建时都访问lock是会造成性能下降

class God{
    private static God instance=null;
    private God(){}
    private static object locker=new object();
    
    public static God GetInstance(){
        lock(locker){
            if(instance==null){
                instance=new God();
            }
            return instance;
        }
    }
}

多线程下双重锁单利：

class God{
    private static God instance=null;
    private God(){}
    private static object locker=new object();
    
    public static God GetInstance(){
        if(instance==null){
            lock(locker){
                if(instance==null){
                    instance=new God();
                }
                return instance;
            }
        }
    }
}

WaitHandle

　　除了锁之外，.Net 中还提供了一些线程间更自由通讯的工具，他们提供了通过“信号”进行通讯的机制，通俗的比喻为“开门”、“关门”：Set()开门，Reset()关门，WaitOne()等着开门

WaitHandle抽象类

ManualResetEvent：手动开关

　　WaitOne()：开一次门

ManualResetEvent mre=new ManualResetEvent(false);//默认值给的是否开门，false关门
Thread t1=new Thread(()=>{
    cw("开始等待着开门");
    mre.WaitOne();//开一次门
    cw.("终于等到你开门");
});
t1.start();
cw("按任意键开门");
cr();
mre.Set();
cr();


//WaitOne()还可以设置等待时间
//mre.Reset()手动关门

　　WaitAll()：用来等待所有信号都变为“开门状态”

　　WaitAny():用来等待任意一个信号都变为“开门状态”。
AutoResetEvent：他是在开门并且一个 WaitOne 通过后自动关门，因此命名为“AutoResetEvent”（Auto 自动-Reset 关门）

AutoResetEvent are = new AutoResetEvent(false);
Thread t1 = new Thread(() => {
while (true)
{
Console.WriteLine("开始等着开门");
are.WaitOne();
Console.WriteLine("终于等到你");
}
});
t1.Start();
Console.WriteLine("按任意键开门");
Console.ReadKey();
are.Set();//开门
Console.WriteLine("按任意键开门");
Console.ReadKey();
are.Set();
Console.WriteLine("按任意键开门");
Console.ReadKey();
are.Set();

ManualResetEvent 就是学校的大门，开门大家都可以进，除非主动关门；

AutoResetEvent:就是火车地铁的闸机口，过了一个后自动关门