2. 程式人生 > >c#多執行緒基礎，操作一

c#多執行緒基礎，操作一

阿新 • • 發佈：2018-11-25

原文https://www.cnblogs.com/wangyulong/p/7750346.html

C#多執行緒程式設計實戰（一）：執行緒基礎

1.1 簡介

為了防止一個應用程式控制CPU而導致其他應用程式和作業系統本身永遠被掛起這一可能情況，作業系統不得不使用某種方式將物理計算分割為一些虛擬的程序，並給予每個執行程式一定量的計算能力。此外作業系統必須始終能夠優先訪問CPU，並能調整不同程式訪問CPU的優先順序。執行緒正式這一慨唸的實現。

多執行緒優點：可以同時執行多個計算任務，有可能提高計算機的處理能力，使得計算機每秒能執行越來越多的命令

多執行緒缺點：消耗大量的作業系統資源。多個執行緒共享一個處理器將導致作業系統忙於管理這些執行緒，而無法執行程式。

1.2 建立執行緒

複製程式碼 
using System;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Thread t1 = new Thread(new ThreadStart(PrintNumbers));//無引數的委託
            t1.Start();
            
            Thread t2 
 
= new Thread(new ParameterizedThreadStart(PrintNumbers));//有引數的委託
            t2.Start(10);
            Console.ReadLine();
        }

        static void PrintNumbers()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i);
            }
        }

        
 
//注意：要使用ParameterizedThreadStart，定義的引數必須為object
        static void PrintNumbers(object count)
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < Convert.ToInt32(count); i++)
            {
                Console.WriteLine(i);
            }
        }
    }
}
複製程式碼

註釋：我們只需指定在不同執行緒執行的方法名，而C#編譯器會在後臺建立這些物件

1.3 暫停執行緒

複製程式碼 
using System;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Thread t1 = new Thread(PrintNumbersWithDelay);
            t1.Start();
            PrintNumbers();
            Console.ReadLine();
        }

        static void PrintNumbers()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                
                Console.WriteLine(i);
            }
        }

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine(i);
            }
        }
    }
}
複製程式碼

註釋：使用Thread.Sleep(TimeSpan.FromSeconds(2));暫停執行緒

1.4 執行緒等待

複製程式碼 
using System;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting...");
            Thread t = new Thread(PrintNumbersWithDelay);
            t.Start();
            t.Join();   //使用Join等待t完成
            PrintNumbers();
            Console.WriteLine("THread Complete");
            Console.ReadLine();
        }

        static void PrintNumbers()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                
                Console.WriteLine(i);
            }
        }

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine(i);
            }
        }
    }
}
複製程式碼

註釋：使用t.Join();   等待t完成

1.5 終止執行緒

複製程式碼 
using System;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting Program...");
            Thread t1 = new Thread(PrintNumbersWithDelay);
            t1.Start();
            Thread.Sleep(TimeSpan.FromSeconds(6));
            t1.Abort();    //使用Abort()終止執行緒
            Console.WriteLine("Thread t1 has been aborted");
            Thread t2 = new Thread(PrintNumbers);
            PrintNumbers();
            Console.ReadLine();
        }

        static void PrintNumbers()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                
                Console.WriteLine(i);
            }
        }

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("Starting...");
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine(i);
            }
        }
    }
}
複製程式碼

註釋：使用Thread例項的Abort方法終止執行緒

1.6 檢測執行緒狀態

複製程式碼 
using System;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Start Program...");
            Thread t1 = new Thread(PrintNumbersWithStatus);
            Thread t2 = new Thread(DoNothing);
            Console.WriteLine(t1.ThreadState.ToString());//獲取例項執行緒狀態
            t2.Start();
            t1.Start();
            for (int i = 0; i < 30; i++)
            {
                Console.WriteLine(t1.ThreadState.ToString());
            }
            Thread.Sleep(TimeSpan.FromSeconds(6));
            t1.Abort();
            Console.WriteLine("thread t1 has been aborted");
            Console.WriteLine(t1.ThreadState.ToString());
            Console.WriteLine(t2.ThreadState.ToString());
            Console.ReadLine();
        }

        private static void PrintNumbersWithStatus()
        {
            Console.WriteLine("Starting...");
            Console.WriteLine(Thread.CurrentThread.ThreadState.ToString());//獲取當前執行緒狀態
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine(i);
            }
        }

        private static void DoNothing()
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
        }
    }
}
複製程式碼

註釋：使用Thread.ThreadState獲取執行緒的執行狀態。ThreadState是一個C#列舉。謹記：不要在程式中使用執行緒終止，否則可能會出現意想不到的結果

1.7 執行緒優先順序

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine($"Current thread priority: {Thread.CurrentThread.Priority}");
            Console.WriteLine("Running on all cores available");//獲取例項執行緒狀態
            RunThreads();

            Thread.Sleep(TimeSpan.FromSeconds(2));
            Console.WriteLine("Running on a single Core");
            //讓作業系統的所有執行緒執行在單個CPU核心上
            Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
            RunThreads();
            Console.ReadLine();
        }

        private static void RunThreads()
        {
            var sample = new ThreadSample();

            var t1 = new Thread(sample.CountNumbers);
            t1.Name = "Thread One";
            var t2 = new Thread(sample.CountNumbers);
            t2.Name = "Thread Two";

            t1.Priority = ThreadPriority.Highest;//使用Priority設定執行緒的優先順序
            t2.Priority = ThreadPriority.Lowest;
            t1.Start();
            t2.Start();

            Thread.Sleep(TimeSpan.FromSeconds(2));
            sample.Stop();
        }
    }

    class ThreadSample
    {
        private bool _isStopped = false;
        public void Stop()
        {
            _isStopped = true;
        }

        public void CountNumbers()
        {
            long counter = 0;
            while (!_isStopped)
            {
                counter++;
            }
            Console.WriteLine($"{Thread.CurrentThread.Name} with {Thread.CurrentThread.Priority} priority has a count={counter.ToString("N0")}");
        }
    }
}
複製程式碼

註釋：單核執行多執行緒耗費的時間比多核的多很多

1.8 前臺執行緒和後臺執行緒

 

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            var sampleForground = new ThreadSample(10);
            var sampleBackground = new ThreadSample(20);
            var t1 = new Thread(sampleForground.CountNumbers);
            t1.Name = "ForegroundThread";   //沒有明確宣告的均為前臺執行緒
            var t2 = new Thread(sampleBackground.CountNumbers);
            t2.Name = "BackgroundThread";
            t2.IsBackground = true;    //設定為後臺執行緒

            t1.Start();
            t2.Start();
        }
    }

    class ThreadSample
    {
        private readonly int _iteration;

        public ThreadSample(int iteration)
        {
            _iteration = iteration;
        }

        public void CountNumbers()
        {
            for (int i = 0; i < _iteration; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
            }
        }
    }
}
複製程式碼

註釋：程序會等待所有的前臺執行緒完成後再結束工作，但是如果只剩下後臺執行緒，則會直接結束工作

1.9 向執行緒傳遞引數

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadSample sample = new ThreadSample(5);

            Thread t1 = new Thread(sample.CountNumbers);
            t1.Name = "ThreadOne";
            t1.Start();
            t1.Join();
            Console.WriteLine("--------------------------");

            Thread t2 = new Thread(Count);
            t2.Name = "ThreadTwo";
            t2.Start(3);
            t2.Join();
            Console.WriteLine("--------------------------");

            //使用lambda表示式引用另一個C#對方的方式被稱為閉包。當在lambda表示式中使用任何區域性變數時，C#會生成一個類，並將該變數作為該類的一個屬性，但是我們無須定義該類，C#編譯器會自動幫我們實現
            Thread t3 = new Thread(()=> CountNumbers(5));
            t3.Name = "ThreadThree";
            t3.Start();
            t3.Join();
            Console.WriteLine("--------------------------");

            int i = 10;
            Thread t4 = new Thread(() => PrintNumber(i));
            
            i = 20;
            Thread t5 = new Thread(() => PrintNumber(i));
            t4.Start();
            t5.Start();
            //t4, t5都會輸出20， 因為t4，t5沒有Start之前i已經變成20了
            Console.ReadKey();
        }

        static void Count(object iterations)
        {
            CountNumbers((int)iterations);
        }

        static void CountNumbers(int iterations)
        {
            for (int i = 1; i <= iterations; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
            }
        }

        static void PrintNumber(int number)
        {
            Console.WriteLine(number);
        }
    }

    class ThreadSample
    {
        private readonly int _iteration;

        public ThreadSample(int iteration)
        {
            _iteration = iteration;
        }

        public void CountNumbers()
        {
            for (int i = 1; i <= _iteration; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
            }
        }
    }
}
複製程式碼

註釋：也可以使用ThreadStart傳遞引數

1.10 使用C# lock關鍵字

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Incorrect Counter");
            Counter c1 = new Counter();
            var t1 = new Thread(() => TestCounter(c1));
            var t2 = new Thread(() => TestCounter(c1));
            var t3 = new Thread(() => TestCounter(c1));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();
            Console.WriteLine($"Total Count: {c1.Count}");
            Console.WriteLine("------------------------");

            Console.WriteLine("Correct counter");
            CounterWithLock c2 = new CounterWithLock();
            t1 = new Thread(() => TestCounter(c2));
            t2 = new Thread(() => TestCounter(c2));
            t3 = new Thread(() => TestCounter(c2));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();
            Console.WriteLine($"Total count:{c2.Count}");
            Console.ReadLine();
        }

        static void TestCounter(CounterBase c)
        {
            for (int i = 0; i < 100000; i++)
            {
                c.Increment();
                c.Decrement();
            }
        }

        class Counter : CounterBase
        {
            public int Count { get; private set; }
            public override void Decrement()
            {
                Count--;
            }

            public override void Increment()
            {
                Count++;
            }
        }

        class CounterWithLock : CounterBase
        {
            private readonly object _asyncRoot = new object();
            public int Count { get; private set; }
            public override void Decrement()
            {
                lock (_asyncRoot)
                {
                    Count--;
                }
            }

            public override void Increment()
            {
                lock (_asyncRoot)
                {
                    Count++;
                }
            }
        }

        abstract class CounterBase
        {
            public abstract void Increment();

            public abstract void Decrement();
        }
    }

    class ThreadSample
    {
        private readonly int _iteration;

        public ThreadSample(int iteration)
        {
            _iteration = iteration;
        }

        public void CountNumbers()
        {
            for (int i = 1; i <= _iteration; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
            }
        }
    }
}
複製程式碼

註釋：不加鎖，得出的結果不確定，競爭條件下很容易出錯。加鎖得出的結果是正確的，但是效能受到了影響

1.11 使用Monitor類鎖定資源

 

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            object lock1 = new object();
            object lock2 = new object();
            new Thread(() => LockTooMuch(lock1, lock2)).Start();
            lock (lock2)
            {
                Thread.Sleep(1000);
                Console.WriteLine("Monitor.TryEnter allows not to get stuck, returning false after a specified timeout is elapsed");
                //直接使用Monitor.TryEnter, 如果在第二個引數之前還未獲取到lock保護的資源會返回false
                if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5)))
                {
                    Console.WriteLine("Acquired a protected resource successfully");
                }
                else
                {
                    Console.WriteLine("Timeout acquiring a resource");
                }
            }
            new Thread(() => LockTooMuch(lock1, lock2)).Start();
            Console.WriteLine("-----------------------------");
            /* 下面程式碼會造成死鎖， 所以註釋掉
            lock (lock2)
            {
                Console.WriteLine("This will be a deadlock!");
                Thread.Sleep(1000);
                lock (lock1)
                {
                    Console.WriteLine("Acquired a protected resource successfully");
                }
            }
            */
        }

        static void LockTooMuch(object lock1, object lock2)
        {
            lock (lock1)
            {
                Thread.Sleep(1000);
                lock (lock2);
            }
        }
    }
}
複製程式碼

註釋：Monitor.TryEnter在指定的時間內嘗試獲取指定物件上的排他鎖

1.12 處理異常

複製程式碼 
using System;
using System.Diagnostics;
using System.Threading;

namespace MulityThreadNote
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t = new Thread(FaultyThread);
            t.Start();
            t.Join();
            try
            {
                t = new Thread(BadFaultyThread);
                t.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine("We won't get here");
            }
        }
        static void BadFaultyThread()
        {
            Console.WriteLine("Starting a faulty thread.....");
            Thread.Sleep(TimeSpan.FromSeconds(2));
            //這個異常主執行緒無法捕捉到，因為是在子執行緒丟擲的異常。需要在子執行緒中加入try...catch捕獲異常
            throw new Exception("Boom!");
        }
        static void FaultyThread()
        {
            try
            {
                Console.WriteLine("Starting a faulty thread...");
                Thread.Sleep(TimeSpan.FromSeconds(1));
                throw new Exception("Boom");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception handled: {ex.Message}");
            }
        }
    }
}
複製程式碼

相關推薦

c#多執行緒基礎，操作一

原文https://www.cnblogs.com/wangyulong/p/7750346.html C#多執行緒程式設計實戰（一）：執行緒基礎 1.1 簡介 為了防止一個應用程式控制CPU而導致其他應用程式和作業系統本身永遠被掛起這一可能情況，作業系統不得不使用某種方式將物理計

C#多執行緒基礎，實現主子執行緒有序輸出

建立控制檯程式 using System; using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; namespace AsyncThread { publi

c++多執行緒重點難點（一）interlocked系列原子操作

_beginthreadex()函式在建立新執行緒時會分配並初始化一個_tiddata塊。這個_tiddata塊自然是用來存放一些需要執行緒獨享的資料。事實上新執行緒執行時會首先將_tiddata塊與自己進一步關聯起來。然後新執行緒呼叫標準C執行庫函式如st

C#多執行緒基礎（多執行緒的優先順序、狀態、同步）

一、關於多執行緒的優先順序、狀態、同步指令碼如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System

C#多執行緒基礎知識和小實踐

源文來源 ：http://www.cnblogs.com/jackson0714/p/5100372.html 一、多執行緒介紹 C#通過多執行緒支援並行執行的程式碼。一個執行緒是一個獨立執行的路徑，可以同時與其他執行緒一起執行。一個C#客戶端程式(Console,WPF,W

Java多執行緒-基礎篇（一）

多執行緒---基礎篇，本文主要針對多執行緒的基礎進行復習，內容包括執行緒的理解，建立方式，Thread類函式理解； 1、執行緒的理解：OS系統角度：每個執行的程式都會被作業系統建立對應的程序（包括分配的資源、PCB等），程序是作業系統分配資源的基本單位（理解：程式執行需要空間，作業系統建立對應程序時

多執行緒基礎知識（一） 執行緒的概念及建立任務與執行緒

執行緒的概念及建立任務與執行緒 引言 多執行緒使得程式中的多個任務可以同時執行。 java的重要功能之一就是內部支援多執行緒————在一個程式中運行同時執行多個任務。在許多程式設計語言中，多執行緒都是通過呼叫依賴於系統的過程或函式來實現的。在本文中，將介紹執行緒的該

Java 多執行緒基礎（十一）執行緒優先順序和守護執行緒

 Java 多執行緒基礎（十一）執行緒優先順序和守護執行緒 一、執行緒優先順序 Java 提供了一個執行緒排程器來監控程式啟動後進去就緒狀態的所有執行緒。執行緒排程器通過執行緒的優先順序來決定排程哪些執行緒執行。一般來說，Java的執行緒排程器採用時間片輪轉演算法使多個執行緒輪轉獲得CPU的時間片。

C++多執行緒基礎教程

[TOC] ## 1 什麼是C++多執行緒？ 執行緒：執行緒是作業系統能夠進行運算排程的最小單位，它被包含在程序之中，程序包含一個或者多個執行緒。**程序可以理解為完成一件事的完整解決方案，而執行緒可以理解為這個解決方案中的的一個步驟，可能這個解決方案就這隻有一個步驟，也可能這個解決方案有多個步驟。**

Python中的多執行緒程式設計，執行緒安全與鎖(一) 聊聊Python中的GIL 聊聊Python中的GIL python基礎之多執行緒鎖機制 python--threading多執行緒總結 Python3入門之執行緒threading常用方法

1. 多執行緒程式設計與執行緒安全相關重要概念 在我的上篇博文 聊聊Python中的GIL 中，我們熟悉了幾個特別重要的概念：GIL，執行緒，程序， 執行緒安全，原子操作。 以下是簡單回顧，詳細介紹請直接看聊聊Python中的GIL  GIL:&n

c#多執行緒操作測試（阻塞執行緒，結束任務）

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Te

一、多執行緒基礎概念、實現執行緒三種方法、中斷執行緒方法，以及執行緒狀態轉化

1、CPU核心數和執行緒數的關係 1:1的關係，引入超執行緒之後，就是1:2 2、cpu時間輪轉機制，即RR排程 3、程序和執行緒 程序：程式執行資源分配最小單位，程序內部有多個執行緒，多個執行緒之間會共享程序資源 執行緒：CPU排程的最小單位 4、並行和併發

C# 多執行緒操作介面時，使用Invoke與BeginInvoke的區別

Invoke方法的引數很簡單，一個委託，一個引數表(可選)，而Invoke方法的主要功能就是幫助你在 UI執行緒(即建立控制元件的執行緒)上呼叫委託所指定的方法。Invoke方法首先檢查發出呼叫的執行緒(即當前執行緒)是不是UI執行緒，如果是，直接執行委託指向 的方法

C++11 併發程式設計基礎（一）：併發、並行與C++多執行緒

正文 C++11標準在標準庫中為多執行緒提供了元件，這意味著使用C++編寫與平臺無關的多執行緒程式成為可能，而C++程式的可移植性也得到了有力的保證。另外，併發程式設計可提高應用的效能，這對對效能錙銖必較的C++程式設計師來說是值得關注的。 回到頂部 1. 何為併發 併發指的是兩個或多個獨立的活動在同

多執行緒系列（一），多執行緒基礎

執行緒相關概念 在學習多執行緒之前，先來了解下幾個與多執行緒相關的概念。 程序：程序是計算機的概念，程式在伺服器執行時佔據全部計算資源的總和，一個應用程式執行起來就是一個程序，開啟windows的工作管理員，如下圖 執行緒：執行緒也是計算機的概念，執行緒是程序的最小單位，也是程式在響應作業系統時的最小單位

多執行緒基礎二（執行緒的啟動、終止，執行緒面臨的三種問題）

一、執行緒的啟動、終止方式  　啟動：　start native（呼叫外部介面啟動）     終止：    stop(類似kill,暴力終止)  interrupt 中斷的方式 通過指令的方式 volatile boolean stop

單執行緒的弊端，多執行緒基礎學習

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using

C# 多執行緒學習系列四之取消、超時子執行緒操作

1、簡介 雖然ThreadPool、Thread能開啟子執行緒將一些任務交給子執行緒去承擔,但是很多時候,因為某種原因,比如子執行緒發生異常、或者子執行緒的業務邏輯不符合我們的預期,那麼這個時候我們必須關閉它,而不是讓它繼續執行,消耗資源.讓CPU不在把時間和資源花在沒有意義的程式碼上.  

Python基礎（四）--- Python多執行緒介紹，開啟執行緒的三種方式，time模組，join，Daemon，Lock、Rlock，事件機制，Timer

一、多執行緒介紹 --------------------------------------------------------- 1.threading用於提供執行緒相關的操作，執行緒是應用程式中工作的最小單元。 2.python當前版本的多執行緒庫沒有實現優先順序、執行緒組，執

C++11多執行緒的原子操作

原子操作是同時只能有一個執行緒執行一個操作，不用使用互斥量即可實現，但是速度慢，而且一般只支援原生的型別，不夠靈活。更多的用處是作為訊號量進行使用。 示例程式碼，以int為例子： #include <atomic> #include <thread> #i