协程与线程总结：
这篇文章属于自己整理，有很多理解不透彻的地方。以后有了更深的理解再做修改。一入代码深似海，越学越不会。
协程与线程在功能上较为类似。
协程：同一时间只能执行一个协程，所有的协程共享一个线程资源，并且会被执行在游戏的主线程上，因为所有的协程是不在同一时间执行的所以添加协程的开销不大。
线程：线程是异步运行的，在多处理器中一个线程可以同时与其他线程同时工作。开辟多线程开销较大。但多线程能够更有效的利用计算机资源，在性能上线程要优于协程。
线程常见问题：同一时间多个线程共同访问方法可能导致方法重复。（比如，多个线程访问一个加载场景的方法，在第一个线程访问场景加载方法未完成时另一个线程也可访问，此时就导致两次加载场景出现逻辑问题，此时就需要用到线程锁来解决）。
Unity函数执行图
当协程被**，它会一直到下一个yield语句执行，然后会暂停知道恢复时继续执行。
协程的实现
协程的开启方式StartCoroutine()。
这个方法有三个重载，
StartCoroutine(IEnumerator routine)枚举器参数
StartCoroutine(strng methodName,[DefaultValue(“null”)]object value) 方法名，传入参数
StartCoroutine(string methodName) 方法名
常见的协程写法案例：
[ContextMenu("Run")]
private void main()
{
StartCoroutine("ILoadScence");
}
IEnumerator ILoadScence()
{
Debug.Log("第一阶段");
AsyncOperation async = SceneManager.LoadSceneAsync(1);
Debug.Log("第二阶段");
while (!async.isDone)
{
Debug.Log("第三阶段");
Debug.Log(async.progress);
yield return null;
Debug.Log("第四阶段");
}
Debug.Log("第五阶段");
}
其实也可以这样写
[ContextMenu("Run")]
private void main()
{
StartCoroutine("ILoadScence");
}
IEnumerator ILoadScence()
{
List<int> list = new List<int>();
...
return list.GetEnumerator();
}
但确实没见人这样用过。主要有些类似上面加载场景的功能这种方法很不适用，因为根本无法获取加载进度。
这里要提一点。协程是由StartCoroutine打开的，所调用的方法并不是协程，出学的时候只知道协程怎么写便一直误以为下面的方法就是协程。
此处使用迭代器实现了枚举。通过上面的代码和截图可以看出这个协程的执行过程。
至于迭代器、枚举器、枚举类等内容此处不做整理。
yield协程当中的任何地方都可以用yield return 来暂停协程，
而yield return 后面的内容代表了在什么时候恢复协程的执行。Yield return 主要可分为两大类yield return 值 和yield return 对象
yield return null; 暂停协程等待下一帧继续执行。
yield return 0/1/2/n; 暂停协程等待下一帧继续执行。
yield return new WairForSeconds(3); 等待3秒后执行。
yield return GameObject; 当游戏对象被获取到之后执行。
yield break; 跳出方法，其后面的代码不会被执行。
多线程
委托线程
（一）
开启一个线程 function.BeginInvoke(OnCallBack,a) 返回一个线程资源对象IAsyncResult。方法的倒数第二个参数是 传递一个委托方法在线程结束时执行 OnCallBack(IAsyncResult ar) { } ar系统自动传入 。 倒数第一个参数表示委托方法的传参 a = ar.AsyncState 在OnCallBack中使用ar.AsyncState代表传入参数
IAsyncResult.IsCompleted==bool 判断线程是否调用完毕。
function.EndInvoke(IAsyncResult) 返回该线程的返回值
ar.AsyncWaitHandle.WaitOne(); 等待线程执行结束
ar.AsyncWaitHandle.WaitOne(100); 最多等待100毫秒。等待过后返回 bool 值线程是否结束
static void Main(string[] args)
{
//
Func<int,int> a = Test;
//倒数第二个参数传递委托 在执行完毕时调用的回调函数
//倒数第一个参数用来给回调函数传递数据
//IAsyncResult ar = a.BeginInvoke(100,OnCallBack,a);
//while(ar.IsCompleted==false)
// Console.WriteLine(".");
//int res =a.EndInvoke(ar);
//Console.WriteLine("go");
//ar.AsyncWaitHandle.WaitOne();//等到结束
//bool isEnd=ar.AsyncWaitHandle.WaitOne(1000);//等待100毫秒
//if (isEnd)
//{
// int res = a.EndInvoke(ar);
// Console.WriteLine(res);
//}
a.BeginInvoke(100, ar =>
{
int res = a.EndInvoke(ar);
Console.WriteLine("在lambda中获得");
}, null);
}
static int Test(int id)
{
Console.WriteLine("test");
Thread.Sleep(100);
Console.WriteLine("test1");
return 100;
}
static void OnCallBack(IAsyncResult ar)
{
Func<int, int> a = ar.AsyncState as Func<int,int>;//ar.AsyncState(就是传进来的a)
int res = a.EndInvoke(ar);
Console.WriteLine("子线程end");
}
（二）thread类
Thread t = new Thread(function);
t.IsBackground=true; 将该线程设置为后台线程
t.start(); 开启线程
t.Join(); 让当前线程睡眠等待 t 线程执行完再继续执行代码
Thread.CurrentThread.ManagedThreadId 当前线程的线程Id
static void Main(string[] args)
{
//Thread t = new Thread(DownloadFile);
//t.Start();
//Console.WriteLine("main");
Thread t = new Thread(() =>
{
Console.WriteLine("开始下载:" + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(2000);
Console.WriteLine("下载完成");
});
t.Start();
}
static void DownloadFile()
{
Console.WriteLine("开始下载:" + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(2000);
Console.WriteLine("下载完成");
}
（二）thread类2
Thread t = new Thread(function);
function可以有参数，但参数必须是object类型的。在 t.start(参数) 中给方法传参
static void Main()
{
Thread t = new Thread(DownloadFile);
t.Start("xxx.种子");
}
static void DownloadFile(object obj)
{
Console.WriteLine("开始下载:"+obj);
}
或者这样做：
static void Main()
{
MyThread my=new MyThread("开心文件","天书中");
Thread t=new Thread(my.DownFile);//传递对象的普通方法
t.Start();
}
class MyThread
{
private string _filename;
private string _filepath;
public MyThread(string fileName, string filepath)
{
_filename = fileName;
_filepath = filepath;
}
public void DownFile()
{
Console.WriteLine("开始下载"+_filepath+_filename);
Thread.Sleep(2000);
Console.WriteLine("下载完成");
}
}
（三）线程池
传入方法必须有参数。线程池是用后台闲置线程运行，所以在前台线程运行结束后会停止
static void Main()
{
Console.WriteLine("可以");
ThreadPool.QueueUserWorkItem(ThreadMethod);
ThreadPool.QueueUserWorkItem(ThreadMethod);
ThreadPool.QueueUserWorkItem(ThreadMethod);
Console.Read();
}
static void ThreadMethod(object state)
{
Console.WriteLine("线程开始:"+Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(2000);
Console.WriteLine("线程关闭");
}
线程任务开启线程
//普通任务
Task t = new Task(ThreadMethod);
t.Start();
//任务工厂
TaskFactory tf = new TaskFactory();
Task t = tf.StartNew(ThreadMethod);
//在一个线程方法中开辟一个子线程。 当子线程未执行完时 父线程 的状态为WaitingForChildrenToComplete
//当子线程和父线程都执行结束时 父线程的状态为RunToCompletion
任务依赖
Task t2 = t1.ContinueWith(DoSecond);
在t1执行完后开辟t2线程执行DoSecond方法
static void Main()
{
Console.WriteLine("开始");
Task t1 = new Task(DoFirst);
Task t2 = t1.ContinueWith(DoSecond);
Task t3 = t1.ContinueWith(DoSecond);
Task t4 = t2.ContinueWith(DoSecond);
t1.Start();
Console.WriteLine("结束");
Console.Read();
}
static void DoFirst()
{
Console.WriteLine("do First"+Task.CurrentId);
Thread.Sleep(3000);
Console.WriteLine("over First");
}
static void DoSecond(Task t)
{
Console.WriteLine("do Second"+Task.CurrentId);
Thread.Sleep(3000);
Console.WriteLine("over Second");
}
防止多个线程对同一个参数进行访问导致逻辑错误使用lock; 例如: int state = 5 ; ChangeState(){ state ++ ; if(state==5){ console.writeline("state=5") }state=5; }
以下两个函数会出现死锁。 在程序设计时要提前设计好避开死锁现象 例如 先申请锁定s1然后才能锁定s2就可防止此现象
func1(){
lock(s1){
lock(s2){}
}
}
func2(){
lock(s2){
lock(s1)
}
}