对异步的理解

写个笔记，只为增强对知识的理解，仅此而已

private static void Main(){
	int loopcount=0;
    while (true)
    {
        int temp = watcherValue;
        
        Thread.Sleep(1);  //主线程等待1秒
        
        ++loopCount;

        //每万次打印一次
        if (loopCount % 10000 == 0)
        {
            Console.WriteLine($"loop count: {loopCount}");
        }
    }
}
//----------------------------------------------------------------------------------------

//增加功能，在5秒之后打印
//5秒之后， sleep(5);

private static void Main(){
	int loopcount=0;
	bool flag=true;
    while (true)
    {
        int temp = watcherValue;
        
        //这样做会打断 每秒打印一次这个主线程的执行
        //因此，这里的等待5秒，不能在里面
        if(flag){
        	//5秒之后打印
        	Thread.Sleep(5);    
       		 //LogSomething
        	flag=flag;
        }
        

        Thread.Sleep(1);  //主线程等待1秒
        
        ++loopCount;

        //每万次打印一次
        if (loopCount % 10000 == 0)
        {
            Console.WriteLine($"loop count: {loopCount}");
        }
    }
}


	private static int loopCount = 0;
    private static void Main()
    {
        OneThreadSynchronizationContext _ = OneThreadSynchronizationContext.Instance;     
        WaitTimeAsync(5000, WaitTimeFinishCallback);  //异步事件     

        //主线城依旧是每秒打印一次
        while (true)
        {
        	//单线程同步上下文
        	//这个单例管理了一个Action委托队列，
        	//轮询队列，执行Action委托
            OneThreadSynchronizationContext.Instance.Update();  
            
            Thread.Sleep(1);           
            ++loopCount;
            if (loopCount % 10000 == 0)
            {
                Console.WriteLine($"loop count: {loopCount}");
            }
        }
    }


    //开启一个新的线城，传入等待的事件，和要执行的委托
    private static void WaitTimeAsync(int waitTime, Action action)
    {
        Thread thread = new Thread(()=>WaitTime(waitTime, action));
        thread.Start();
    }


	 private static void WaitTime(int waitTime, Action action)
    {
        Thread.Sleep(waitTime);
        
        // 如果当前的线性是主线程，则执行委托
        // 如果当前的线城不是主线城，则 则将 委托加入到 单例的队列里面，这样主线程轮询的时候，会调用
        OneThreadSynchronizationContext.Instance.Post((o)=>action(), null);
    }

//--------------------------------------------------------------------------------------------------
//又有了新需求了， 在执行玩回调后，等待2秒，打印一点东西

private static void WaitTimeAsync(int waitTime, Action action)
    {
        Thread thread = new Thread(()=>WaitTime(waitTime, action));
        thread.Start();
    }
    private static void WaitTimeFinishCallback()
    {
        Console.WriteLine($"WaitTimeAsync finsih loopCount的值是: {loopCount}");
        WaitTimeAsync(3000, WaitTimeFinishCallback2);
    }
    
    private static void WaitTimeFinishCallback2()
    {
        Console.WriteLine($"WaitTimeAsync finsih loopCount的值是: {loopCount}");
    }

//OneThreadSynchronizationContext  是放在主线程中的容器， 
//异步等待，就是开一个新线城，新线城休息 几秒后， 把委托 扔给 这个容器
// 主线城轮询队列容器， 执行委托
//原理很简单
//----------------------------------------

//语法糖： 改变写法，方便撸代码
 private static int loopCount = 0;
      
      static void Main(string[] args)
      {
          OneThreadSynchronizationContext _ = OneThreadSynchronizationContext.Instance;              
          Crontine();    //异步事件，替换  WaitTimeAsync(5000, WaitTimeFinishCallback);      
          while (true) 
          {
              OneThreadSynchronizationContext.Instance.Update();
              
              Thread.Sleep(1);
              
              ++loopCount;
              if (loopCount % 10000 == 0)
              {
                  Console.WriteLine($"loop count: {loopCount}");
              }
          }
      }

//async 声明异步函数
 private static async void Crontine()  
      {
      	//需要异步执行的任务
          await WaitTimeAsync(5000);
          Console.WriteLine($"当前线程: {Thread.CurrentThread.ManagedThreadId}, WaitTimeAsync finsih loopCount的值是: {loopCount}");
          await WaitTimeAsync(4000);
          Console.WriteLine($"当前线程: {Thread.CurrentThread.ManagedThreadId}, WaitTimeAsync finsih loopCount的值是: {loopCount}");
          await WaitTimeAsync(3000);
          Console.WriteLine($"当前线程: {Thread.CurrentThread.ManagedThreadId}, WaitTimeAsync finsih loopCount的值是: {loopCount}");
      }

 private static Task WaitTimeAsync(int waitTime)
      {
          TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();  //代替传入的 Action委托
          Thread thread = new Thread(()=>WaitTime(waitTime, tcs));
          thread.Start();
          return tcs.Task;
      } 

 private static void WaitTime(int waitTime, TaskCompletionSource<bool> tcs)
      {
          Thread.Sleep(waitTime);
          
          // 将tcs扔回主线程执行
          OneThreadSynchronizationContext.Instance.Post(o=>tcs.SetResult(true), null);
      }



//---------------------------------------------------------------------------------
 // 多线程异步，是看起了一个新线程，
 // 单线程异步的实现

    private static int loopCount = 0;
    private static long time;
    private static Action action;
    
    static void Main(string[] args)
    {
        Console.WriteLine($"主线程: {Thread.CurrentThread.ManagedThreadId}");

        Crontine();  //异步任务
        
        while (true)
        {
            Thread.Sleep(1);

            CheckTimerOut();  //还是采样轮询的方式
            
            ++loopCount;
            if (loopCount % 10000 == 0)
            {
                Console.WriteLine($"loop count: {loopCount}");
            }
        }
    }


     private static void Crontine()
    {
        WaitTimeAsync(5000, WaitTimeAsyncCallback1);
    }

     private static void WaitTimeAsync(int waitTime, Action a)
    {
        time = DateTime.Now.Ticks / 10000 + waitTime;   //终止的时间戳
        action = a;
    }

    //轮询逻辑
     private static void CheckTimerOut()
    {
        if (time == 0)
        {
            return;
        }
        long nowTicks = DateTime.Now.Ticks / 10000;
        if (time > nowTicks)
        {
            return;
        }

        time = 0;
        action.Invoke();
    }