線程基礎 #c#

線程基礎

一、簡介

1.為了防止一個應用程式控制CPU而導緻其他應用程式和作業系統本身永遠被挂起這一可能情況，作業系統不得不使用某種方式将實體計算分割為一些虛拟的程序，并給予每個執行程式一定量的計算能力。此外作業系統必須始終能夠優先通路CPU，并能調整不同程式通路CPU的優先級。線程正式這一慨念的實作。

2.多線程優缺點：

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

多線程缺點：消耗大量的作業系統資源。多個線程共享一個處理器将導緻作業系統忙于管理這些線程，而無法運作程式。

二、建立線程

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("1.Starting...");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i);
            }
        }

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

注釋：

1.我們隻需指定在不同線程運作的方法名，而C#編譯器會在背景建立這些對象。

2.要使用ParameterizedThreadStart，定義的參數必須為object類型。

三、暫停線程

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

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

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("2.Starting...");
            for (int i = 0; i < 10; i++)
            {
                //var a = TimeSpan.FromSeconds(2);
                Thread.Sleep(TimeSpan.FromSeconds(2));//暫停兩秒
                Console.WriteLine("In 2.Starting: " + i);
            }
        }
    }

注釋：使用Thread.Sleep(TimeSpan.FromSeconds(2));暫停線程一段時間

四、線程等待

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting...");
            Thread t = new Thread(PrintNumbersWithDelay);
            t.Start();
            t.Join();   //使用Join等待t完成後，再向下執行PrintNumbers，如果注釋掉輸出明顯不同
            PrintNumbers();
            Console.WriteLine("Thread Complete");
            Console.ReadLine();
        }

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

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("2.Starting...");
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine("In 2.Starting:" + i);
            }
        }
    }

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

五、終止線程

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting Program...");
            Thread t1 = new Thread(PrintNumbersWithDelay);
            t1.Start();
            Thread.Sleep(TimeSpan.FromSeconds(7));//此時t1線程會執行7秒
            t1.Abort();    //使用Abort()終止線程
            Console.WriteLine("Thread t1 has been aborted");
            Thread t2 = new Thread(PrintNumbers);
            t2.Start();
            Console.ReadLine();
        }

        static void PrintNumbers()
        {
            Console.WriteLine("1.Starting...");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("In 1.Starting:" + i);
            }
        }
        static void PrintNumbersWithDelay()
        {
            Console.WriteLine("2.Starting...");
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine("In 2.Starting:" + i);
            }
        }
    }

注釋：使用Thread執行個體的Abort方法終止線程。

六、檢測線程狀态

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Start Program...");
            Thread t1 = new Thread(PrintNumbersWithStatus);
            Thread t2 = new Thread(DoNothing);
            Console.WriteLine("t1 status:" + t1.ThreadState.ToString());//擷取執行個體線程狀态
            t2.Start();
            t1.Start();
            for (int i = 0; i < 30; i++)
            {
                Console.WriteLine("t1 status:" + t1.ThreadState.ToString() + "\t" + "t2 status:" + t2.ThreadState.ToString());
            }
            Thread.Sleep(TimeSpan.FromSeconds(7));
            t1.Abort();
            Console.WriteLine("thread t1 has been aborted");
            Console.WriteLine("t1 status:" + t1.ThreadState.ToString());
            Console.WriteLine("t2 status:" + t2.ThreadState.ToString());
            Console.ReadLine();
        }

        private static void PrintNumbersWithStatus()
        {
            Console.WriteLine("1.Starting...");
            Console.WriteLine("In 1.Starting t1 status:" + Thread.CurrentThread.ThreadState.ToString());//擷取目前線程狀态
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine("In 1.Starting:" + i);
            }
        }

        private static void DoNothing()
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Console.WriteLine("t2 Console...");
        }
    }

注釋：使用Thread.ThreadState擷取線程的運作狀态。ThreadState是一個C#枚舉。謹記：不要在程式中使用線程終止，否則可能會出現意想不到的結果

七、線程優先級

class Program
    {
        static void Main(string[] args)
        {
            //讓作業系統的所有線程運作在多個CPU核心上
            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();//此處t2優先級低于t1,t2等待t1釋放資源。

            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")}");
        }
    }

注釋：單核執行多線程耗費的時間比多核的多很多。

八、前台線程和背景線程

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();
            Console.ReadLine();

        }
    }
    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}");
            }
        }
    }

注釋：程序會等待所有的前台線程完成後再結束工作，但是如果隻剩下背景線程，則會直接結束工作。

九、向線程傳遞參數

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}");
            }
        }
    }

十、使用C# Lock 關鍵字

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("------------------------");

            //使用LOCK關鍵字，Count同一時刻隻允許一個線程通路
            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}");
            }
        }
    }

注釋：不加鎖，得出的結果不确定，競争條件下很容易出錯。加鎖得出的結果是正确的，但是性能受到了影響

十一、使用Monitor類鎖定資源

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在指定的時間内嘗試擷取指定對象上的排他鎖

十二、處理異常

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 bad 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}");
            }
        }
    }

本文來自部落格園，作者：農碼一生，轉載請注明原文連結：https://www.cnblogs.com/wml-it/p/14808097.html

技術的發展日新月異，随着時間推移，無法保證本部落格所有内容的正确性。如有誤導，請大家見諒，歡迎評論區指正！ 個人開源代碼連結: GitHub:

https://github.com/ITMingliang

Gitee:

https://gitee.com/mingliang_it

GitLab:

https://gitlab.com/ITMingliang

進開發學習交流群：

線程基礎

繼續閱讀

Unity3D中背景音樂和相關音效的添加，背景音樂暫停、停止和播放的設定

Unity遊戲開發背景知識

vs編譯完提示不支援嘗試的執行操作

【C# MySQL】第一次使用C#對MySQL進行操作的心得

C#基礎——與C#的第一次邂逅聲明：IDE：第一個C#果實：Console淺析：總結：

英文月日年日期格式的實作

C# 位元組數組 byte[] 快速比較算法

C# 位元組數組、字元串轉化位元組數組轉字元串字元串轉位元組數組位元組數組轉整數整數轉位元組數組字元串轉位元組字元串轉數值數值轉字元串

C#用Zlib壓縮或解壓縮位元組數組

C# 比較兩個位元組數組是否相等

對于VS中scanf報錯永久解決，建立源檔案自動添加#define _CRT_SECURE_NO_WARNINGS 1

《C#進階程式設計》讀書筆記 -索引

CQ V1.0分詞bates(基于雙數組tire樹)—應該是目前最快的中文分詞算法

C#多線程——前台線程和背景線程

C#+ArcEngine代碼檢測ArcEngine Runtime是否安裝以及是否授權

七牛雲-C#SDK-上傳-前期準備