스 레 드 기반 및 비동기 실행 계산 제한

스 레 드 기반
프로 세 스 는 응용 프로그램의 인 스 턴 스 가 자원 의 집합 을 사용 해 야 합 니 다.windows 커 널 의 데이터 와 코드 와 소통 할 수 없 으 며 시스템 의 건장 성 을 유지 합 니 다.
스 레 드 는 다른 프로그램 과 섞 이지 않도록 가상 cpu 입 니 다. 결국 운영 체제 가 마비 되 었 습 니 다.
스 레 드 의 요소: 스 레 드 커 널 대상, 스 레 드 환경 블록, 사용자 모드 스 택, 커 널 모드 스 택, Dll 스 레 드 링크 와 스 레 드 분리 알림.
A. 스 레 드 커 널 대상: 모든 스 레 드 가 초기 화 될 때 이런 데이터 구 조 를 가지 고 있 습 니 다.데이터 구 조 는 스 레 드 의 속성 과 스 레 드 컨 텍스트 를 설명 합 니 다. (컨 텍스트 는 메모리 블록 이 고 주로 CPU 의 레지스터 집합 을 포함 합 니 다. 레지스터 는 cpu 의 구성 부분 으로 임시 저장 명령, 데이터 와 주 소 를 사용 할 수 있 습 니 다.)
B. 스 레 드 환경 블록: 사용자 모드 에서 할당 되 고 초기 화 된 메모리 블록 (메모 리 는 CPU 의 연산 데 이 터 를 일시 적 으로 저장 하고 하 드 디스크 등 외부 메모리 와 교환 하 는 데이터)
C. 사용자 모드 스 택: 전송 방법 에 대한 변수 와 실제 참 조 를 저장 합 니 다.방법 이 실행 되 고 어디서 계속 되 는 지 아 는 주소 도 포함 되 어 있 습 니 다.
D. 커 널 모드 스 택: 프로그램 이 운영 체제 커 널 과 접촉 해 야 한다 면 사용자 모드 스 택 의 데 이 터 를 커 널 모드 스 택 에 전송 하고 검증 을 거 친 후에 os 에 관련 작업 을 하도록 해 야 합 니 다.
E. dll 스 레 드 링크 와 스 레 드 분리 알림, 표지 입 니 다.
시간 편의 전환 은 운영 체제 로 하여 금 하나의 프로그램 이 순환 에 들 어간 후에 다른 프로그램 을 계속 실행 할 수 있 게 한다. 운영 체 제 를 다시 시작 하지 않 아 도 되 지만 전환 은 효율 에 영향 을 미친다.
clr 는 windows 의 스 레 드 처리 능력 을 사용 합 니 다.

Console.WriteLine("Main thread: starting a dedicated thread " +
           "to do an asynchronous operation");
        Thread dedicatedThread = new Thread(ComputeBoundOp);
        dedicatedThread.Start(5);

        Console.WriteLine("Main thread: Doing other work here...");
        //Thread.Sleep(10000);     // Simulating other work (10 seconds)

        dedicatedThread.Join();  //   dedicatedThread              
        Console.WriteLine("haiziguo");
        Console.ReadLine();
    }

    // This method's signature must match the ParametizedThreadStart delegate
    private static void ComputeBoundOp(Object state)
    {
        // This method is executed by a thread pool thread

        Console.WriteLine("In ComputeBoundOp: state={0}", state);
        Thread.Sleep(10000);  // Simulates other work (1 second)

        // When this method returns, the dedicated thread dies
    }

모든 프론트 스 레 드 가 멈 추고 백 스테이지 스 레 드 가 멈 춰 야 하 며 이상 을 던 지지 않 습 니 다.
계산 제한 비동기 프로 그래 밍 - 스 레 드 탱크
CLR 은 코드 를 포함 하여 자신의 스 레 드 풀 을 관리 합 니 다.하나의 CLR 에는 스 레 드 탱크 가 포함 되 어 있다.
기본 스 레 드 탱크 에서 만 든 스 레 드 는 모두 배경 스 레 드 입 니 다.
스 레 드 탱크 는 자신의 스 레 드 를 작업 자 스 레 드 와 IO 스 레 드 로 나 누 었 다.
IO 스 레 드 는 코드 의 비동기 IO 제한 작업 이 완료 되 었 음 을 알려 주 는 데 사 용 됩 니 다.
비동기 프로 그래 밍 모드 에서 IO 요청 을 보 냅 니 다. 예 를 들 어 파일, 네트워크 서버, 데이터 베이스, 웹 서비스, 기타 하드웨어 장치 에 접근 합 니 다.
스 레 드 컨 텍스트 (CallContext) 는 보통 메 인 스 레 드 에서 보조 스 레 드 로 흘러 가 메 인 스 레 드 와 보조 스 레 드 의 각종 권한 을 일치 시 키 므 로 유동 을 막 을 수 있 습 니 다.

CallContext.LogicalSetData("Name", "Jeffrey");

        // Initiate some work to be done by a thread pool thread
        // The thread pool thread can access the logical call context data 
        ThreadPool.QueueUserWorkItem(
           state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));


        // Suppress the flowing of the Main thread’s execution context
        ExecutionContext.SuppressFlow();

        // Initiate some work to be done by a thread pool thread
        // The thread pool thread can NOT access the logical call context data
        ThreadPool.QueueUserWorkItem(
           state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));

스 레 드 작업 취소:

private static void CancellingAWorkItem()
    {
        CancellationTokenSource cts = new CancellationTokenSource();

        // Pass the CancellationToken and the number-to-count-to into the operation
        ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 1000));

        Console.WriteLine("Press <Enter> to cancel the operation.");
        Console.ReadLine();
        cts.Cancel();  // If Count returned already, Cancel has no effect on it
        // Cancel returns immediately, and the method continues running here...

        Console.ReadLine();  // For testing purposes
    }

    private static void Count(CancellationToken token, Int32 countTo)
    {
        for (Int32 count = 0; count < countTo; count++)
        {
            if (token.IsCancellationRequested)
            {
                Console.WriteLine("Count is cancelled");
                break; // Exit the loop to stop the operation
            }

            Console.WriteLine(count);
            Thread.Sleep(200);   // For demo, waste some time
        }
        Console.WriteLine("Count is done");
    }

취소 되 지 않 으 면 Token 의 정적 변 수 를 입력 할 수 있 습 니 다.CancellationTokenSource. CreateLinkedTokenSource (cts1. Token, cts2. Token) 를 사용 할 수 있 습 니 다.여러 개 를 만 들 고, 하 나 를 취소 하면 링크 드 TokenSource 가 취 소 됩 니 다.여러 개 를 만 들 수 있 습 니 다.
계산 제한 비동기 프로 그래 밍 - 작업
스 레 드 탱크 의 QueueUserWork Item 이 반환 값 이 없어 서 언제 끝 날 지 모 르 겠 습 니 다.반환 값 이 포 함 된 Task 코드 를 드 리 겠 습 니 다.

Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);

        // You can start the task sometime later
        t.Start();

        // Optionally, you can explicitly wait for the task to complete
        t.Wait(); // FYI: Overloads exist accepting a timeout/CancellationToken


        // Get the result (the Result property internally calls Wait) 
        Console.WriteLine("The sum is: " + t.Result);   // An Int32 value

Task 바 는 Wait 의 두 가지 상황 을 사용 합 니 다. a. start 를 시 작 했 습 니 다. Task 의 스 레 드 를 호출 하여 Task 가 완 료 될 때 까지 차단 합 니 다.b. start 가 없 으 면 Task 스 레 드 를 호출 하 는 데 차단 이 되 지 않 고 Task 가 완 료 된 후에 야 스 레 드 가 원래 실행 중인 작업 을 계속 합 니 다.하 나 는 '스 레 드 블록' 이 고 하 나 는 '절차 블록' 이 라 고 이해 할 수 있다.
Task 에 이상 이 생기 면 wait 와 result 를 사용 할 때 만 발견 할 수 있 습 니 다.
취소 작업 을 판단 하 는 방법 을 보 여 줍 니 다.

private static Int32 Sum(CancellationToken ct, Int32 n)
    {
        Int32 sum = 0;
        for (; n > 0; n--)
        {

            // The following line throws OperationCanceledException when Cancel 
            // is called on the CancellationTokenSource referred to by the token
            //    CancellationToken   ，       ，
            //          ，           
            ct.ThrowIfCancellationRequested();
          Console.WriteLine(n);
            //Thread.Sleep(0);   // Simulate taking a long time
            checked { sum += n; }
        }
        return sum;
    }

private static void Cancel()
    {
        CancellationTokenSource cts = new CancellationTokenSource();
        Task<Int32> t = new Task<Int32>(() => Sum(cts.Token, 10000), cts.Token);

        t.Start();

        // Sometime later, cancel the CancellationTokenSource to cancel the Task
        cts.Cancel();

        try
        {
            // If the task got canceled, Result will throw an AggregateException
            Console.WriteLine("The sum is: " + t.Result);   // An Int32 value
        }
        catch (AggregateException ae)
        {
            // Consider any OperationCanceledException objects as handled. 
            // Any other exceptions cause a new AggregateException containing 
            // only the unhandled exceptions to be thrown          
            ae.Handle(e => e is OperationCanceledException);

            // If all the exceptions were handled, the following executes
            Console.WriteLine("Sum was canceled");
        }
    }

한 임 무 를 완성 한 후 다른 임 무 를 계속 하면 계속 하 는 임 무 는 자동 으로 시 작 됩 니 다.

//          
        // Create Task, defer starting it, continue with another task
        Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);

        // You can start the task sometime later
        t.Start();

        // ContinueWith returns a Task but you usually don't care
        Task cwt = t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result));
        //cwt.Start();

정시 계산 제한 작업 을 실행 하 다.

//
        //   :
        //       32              ，     Timer      。
        //
        //   :
        //   callback:
        //        System.Threading.TimerCallback   ，        。
        //
        //   state:
        //                      ，    null。
        //
        //   dueTime:
        //        callback         （      ）。    System.Threading.Timeout.Infinite         。
        //         (0)         。
        //
        //   period:
        //        callback      （      ）。    System.Threading.Timeout.Infinite         。
        //
        //   :
        //   System.ArgumentOutOfRangeException:
        //     dueTime   period     ，      System.Threading.Timeout.Infinite。
        //
        //   System.ArgumentNullException:
        //     callback     null。
        [CLSCompliant(false)]
        [SecuritySafeCritical]
        public Timer(TimerCallback callback, object state, uint dueTime, uint period);

스 레 드 탱크 는 모든 Timer 대상 에 게 하나의 스 레 드 만 사용 합 니 다.첫 번 째 대상 이 아직 실행 되 지 않 았 을 때 다음 이 시 작 됩 니 다. timer 를 중복 실행 하 는 사건 이 발생 할 것 입 니 다. 이러한 사건 의 방생 을 방지 하기 위해 서 는 다음 과 같 을 수 있 습 니 다.

Timer timer = new Timer((s) =>
        {
            for (int i = 0; i < 1000; i++)
            {
                Console.WriteLine(i);
            }
        }, null, 0,Timeout.Infinite);
        Thread.Sleep(5000);
        timer.Change(0, Timeout.Infinite);

Timeout. Infinite 를 사용 하고 Change 를 사용 합 니 다.