C# 多线程

1、多线程

一个线程是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，可以通过代码开启新的线程，同时运行代码的多条管道

2、语法相关

线程类 Thread

需要引用命名空间 using System.Threading;

（1）声明一个新的线程

注意：线程执行的代码需要封装到一个函数中，通过委托传入构造函数

新线程将要执行的代码逻辑被封装到了一个函数语句块中 

static void NewThreadLogic() {
    // 新开线程的执行逻辑，在该函数语句块中
    while(true) {
        Console.WriteLine("新开的线程");
    }
}

Thread t = new Thread(NewThreadLogic);

（2）启动线程

t.Start();

（3）设置为后台线程

当前台线程都结束了的时候，整个程序也就结束了，即使还有后台线程正在运行

后台线程不会防止应用程序的进程被终止掉

如果不设置为后台线程，可能导致进程无法正常关闭

t.IsBackground = true;

（4）关闭释放一个线程

如果开启的线程中不是一个死循环，是能够结束的逻辑，那么不用刻意的去关闭它

t = null; // 可以让其变为垃圾

如果是死循环，想要中止这个线程，有两种方式

• 死循环中 bool 标识

static bool isRunning = true;

static void NewThreadLogic() {
    // 新开线程的执行逻辑，在该函数语句块中
    while(isRunning) {
        Console.WriteLine("新开的线程");
    }
}

在需要停止线程时

isRunning = false;

• 通过线程提供的方法（注意在.Net core版本中无法中止，会报错）

t.Abort();
t = null;

（5）线程休眠

// 让线程休眠多少 ms
// 在哪个线程执行就休眠哪个线程
Thread.Sleep(1000);

3、线程之间共享数据

多个线程使用的内存是共享的，都属于该应用程序（进程），所以当多线程同时操作同一片内存区域时可能会出问题，可以通过加锁的形式避免问题

当要在多个线程当中想要访问同样的东西，进行逻辑处理时，为了避免不必要的逻辑顺序执行的差错

lock (引用类型对象) {
    // 逻辑语句块
}

但是锁会影响线程的效率

4、多线程的意义

让多线程专门处理一些复杂耗时的逻辑，比如寻路、网络通信等等

 5、练习——贪吃蛇输入

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Exercise{
    enum E_MoveDir {
        Up,
        Down,
        Right,
        Left,
    }

    class Icon {
        public E_MoveDir dir;
        public int x;
        public int y;

        public Icon(int x, int y, E_MoveDir dir) {
            this.x = x;
            this.y = y;
            this.dir = dir;
        }

        public void Move() {
            switch (dir) {
                case E_MoveDir.Up:
                    y -= 1;
                    break;
                case E_MoveDir.Down:
                    y += 1;
                    break;
                case E_MoveDir.Right:
                    x += 2;
                    break;
                case E_MoveDir.Left:
                    x -= 2;
                    break;
                default:
                    break;
            }
        }

        public void Draw() {
            Console.SetCursorPosition(x, y);
            Console.ForegroundColor = ConsoleColor.Red;
            Console.Write("■");
        }

        public void Clear() {
            Console.SetCursorPosition(x, y);
            Console.Write("    ");
        }

        public void ChangeDir(E_MoveDir dir) {
            this.dir = dir;
        }
    }

    class Program {
        static Icon icon;
        static void Main(string[] args) {
            icon = new Icon(10, 20, E_MoveDir.Right);
            Thread t = new Thread(NewThreadLogic);
            t.Start();
            Console.CursorVisible = false;

            icon.Draw();
            while (true) {
                Thread.Sleep(200);
                icon.Clear();
                icon.Move();
                icon.Draw();
            }

            Console.ReadKey();
        }

        static void NewThreadLogic() {
            while (true) {
                switch (Console.ReadKey(true).Key) {
                    case ConsoleKey.W:
                        icon.ChangeDir(E_MoveDir.Up);
                        break;
                    case ConsoleKey.S:
                        icon.ChangeDir(E_MoveDir.Down);
                        break;
                    case ConsoleKey.A:
                        icon.ChangeDir(E_MoveDir.Left);
                        break;
                    case ConsoleKey.D:
                        icon.ChangeDir(E_MoveDir.Right);
                        break;
                    default:
                        break;
                }
            }
        }
    }

    
}