ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

C#线程基础

2020-05-30 15:07:03  阅读:156  来源: 互联网

标签:Console Name Thread C# 基础 t1 线程 new public


暂停线程:

 static void Main(string[] args)
        {
            Thread thread = new Thread(Common.PrintNumbersWithDelay);
            thread.Start();
            Common.PrintNumbers();
            Console.ReadKey();
        }

  等待线程:

Thread thread = new Thread(Common.PrintNumbersWithDelay);
            thread.Start();
            
            // 等待线程
            thread.Join();

            Console.WriteLine("打印完成!");
            Console.ReadKey();

  终止线程:

static void Main(string[] args)
        {
            Console.WriteLine("主线程开始...");
            //创建一个子线程并启动
            Thread t = new Thread(Common.PrintNumbersWithDelay);
            t.Start();

            // 主线程暂停6秒
            Thread.Sleep(TimeSpan.FromSeconds(6));

            // 终止子线程t
            t.Abort();
            Console.WriteLine("子线程终止了...");

            Thread t1 = new Thread(Common.PrintNumbers);
            t1.Start();
            Common.PrintNumbers();

            Console.ReadKey();

        }

  检测线程状态:

 static void Main(string[] args)
        {
            Thread t1 = new Thread(Common.PrintNumbersWithStatus);
            t1.Name = "t1";
            Thread t2 = new Thread(DoNothing);
            t2.Name = "t2";
            Console.WriteLine($"线程{t1.Name}的状态是:{t1.ThreadState.ToString()}");
            Console.WriteLine($"线程{t2.Name}的状态是:{t2.ThreadState.ToString()}");

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

            for (int i = 0; i < 30; i++)
            {
                Console.WriteLine($"线程{t1.Name}的状态是:{t1.ThreadState.ToString()}");
            }

            Thread.Sleep(TimeSpan.FromSeconds(4));
            t1.Abort();
            Console.WriteLine($"线程{t1.Name}的状态是:{t1.ThreadState.ToString()}");
            Console.WriteLine($"线程{t2.Name}的状态是:{t2.ThreadState.ToString()}");

            Console.ReadKey();
        }

        static void DoNothing()
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
        }

  线程优先级:

 class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine($"主线程{Thread.CurrentThread.Name}的优先级是{Thread.CurrentThread.Priority}");
            Console.WriteLine("在所有CPU内核上运行线程");
            RunThreads();
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("在一个CPU内核上运行线程");
            Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
            RunThreads();
            Console.ReadKey();
        }

        static void RunThreads()
        {
            ThreadSample sample = new ThreadSample();
            Thread t1 = new Thread(sample.CountNumbers);
            t1.Name = "t1";
            Thread t2 = new Thread(sample.CountNumbers);
            t2.Name = "t2";

            t1.Priority = ThreadPriority.Highest;
            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 count = 0;
            while(!_isStopped)
            {
                count++;
            }

            Console.WriteLine($"线程{Thread.CurrentThread.Name}的优先级是{Thread.CurrentThread.Priority},计数器的值为{count}");
        }
    }

  前后台线程:

 class Program
    {
        static void Main(string[] args)
        {
            var sampleForeground = new ThreadSample(10);
            var sampleBackground = new ThreadSample(20);

            // 区别:进程会等待所有的前台线程完成后再结束工作,但是如果最后只剩下后台线程,则会直接结束工作
            var t1 = new Thread(sampleForeground.CountNumbers);
            t1.Name = "前台线程";
            var t2 = new Thread(sampleBackground.CountNumbers);
            t2.Name = "后台线程";
            t2.IsBackground = true;

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

        }
    }

    class ThreadSample
    {
        private readonly int _count;

        public ThreadSample(int count)
        {
            _count = count;
        }

        public void CountNumbers()
        {
            for (int i = 0; i < _count; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} 输出 {i}");
            }
        }
    }

  线程传递参数:

class Program
    {
        static void Main(string[] args)
        {
            var sample = new ThreadSample(10);
            var t1 = new Thread(sample.CountNumbers);
            t1.Name = "t1";
            t1.Start();
            t1.Join();
            Console.WriteLine("===================================");

            var t2 = new Thread(Count);
            t2.Name = "t2";
            t2.Start(8);
            t2.Join();
            Console.WriteLine("===================================");

            // 使用lambda表达式引用另一个C#对象的方式被称为闭包
            var t3 = new Thread(() => { CountNumbers(9); });
            t3.Name = "t3";
            t3.Start();
            t3.Join();
            Console.WriteLine("===================================");

            // 在lambda表达式中使用任何局部变量时,C#会生成一个类,并将该变量作为该类的一个属性
            // 共享该变量值
            int i = 10;
            var t4 = new Thread(() => { PrintNumbers(i); });
            t4.Name = "t4";
            i = 12;
            var t5 = new Thread(() => { PrintNumbers(i); });
            t5.Name = "t4";
            t4.Start();
            t5.Start();
            Console.ReadKey();
        }

        static void CountNumbers(int count)
        {
            for (int i = 0; i < count; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"线程{Thread.CurrentThread.Name}输出{i}");
            }
        }

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

        static void PrintNumbers(int number)
        {
            Console.WriteLine($"线程{Thread.CurrentThread.Name}输出{number}");
        }
    }

    class ThreadSample
    {
        private readonly int _count;

        public ThreadSample(int count)
        {
            _count = count;
        }

        public void CountNumbers()
        {
            for (int i = 0; i < _count; i++)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
                Console.WriteLine($"{Thread.CurrentThread.Name} 输出 {i}");
            }
        }
    }

  Lock:

 public abstract class CounterBase
    {
        public abstract void Increase();
        public abstract void Decrease();
    }

  

public class CounterNoLock : CounterBase
    {
        public int Count { get; private set; }

        public override void Decrease()
        {
            Count--;
        }

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

  

 public class CounterWithLock : CounterBase
    {
        public int Count { get; private set; }

        private readonly object _syncObj = new object();

        public override void Decrease()
        {
            lock(_syncObj)
            {
                Count--;
            }
        }

        public override void Increase()
        {
            lock (_syncObj)
            {
                Count++;
            }
        }
    }

  

 class Program
    {
        static void Main(string[] args)
        {
            CounterNoLock counterNoLock = new CounterNoLock();

            Thread t1 = new Thread(() => { TestCounter(counterNoLock); });
            t1.Name = "t1";
            Thread t2 = new Thread(() => { TestCounter(counterNoLock); });
            t2.Name = "t2";
            Thread t3 = new Thread(() => { TestCounter(counterNoLock); });
            t3.Name = "t3";

            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();

            Console.WriteLine($"没有锁的计数器结果:{counterNoLock.Count}");

            CounterWithLock counterWithLock = new CounterWithLock();

            Thread tt1 = new Thread(() => { TestCounter(counterNoLock); });
            tt1.Name = "tt1";
            Thread tt2 = new Thread(() => { TestCounter(counterNoLock); });
            tt2.Name = "tt2";
            Thread tt3 = new Thread(() => { TestCounter(counterNoLock); });
            tt3.Name = "tt3";

            tt1.Start();
            tt2.Start();
            tt3.Start();
            tt1.Join();
            tt2.Join();
            tt3.Join();
            Console.WriteLine($"有锁的计数器结果:{counterWithLock.Count}");


            Console.ReadKey();
        }

        static void TestCounter(CounterBase counter)
        {
            for (int i = 0; i < 100000; i++)
            {
                counter.Increase();
                counter.Decrease();
            }
        }
    }

  Monitor

 public class Player
    {
        public string Name { get; private set; }

        public int Atk { get; private set; }

        public Player(string name, int atk)
        {
            Name = name;
            Atk = atk;
        }

        public void Attack(YaoGuai yaoGuai)
        {
            while(yaoGuai.Blood > 0)
            {
                Console.WriteLine($"我是{Name},我来打妖怪~");
                yaoGuai.BeAttacked(Atk);
            }
        }
    }

  

public class PlayerWithMonitor
    {
        public string Name { get; private set; }

        public int Atk { get; private set; }

        public PlayerWithMonitor(string name, int atk)
        {
            Name = name;
            Atk = atk;
        }

        public void Attack(YaoGuai yaoGuai)
        {
            while (yaoGuai.Blood > 0)
            {
                Monitor.Enter(yaoGuai);
                Console.WriteLine($"我是{Name},我来打妖怪~");
                yaoGuai.BeAttacked(Atk);
                Monitor.Exit(yaoGuai);
            }
        }
    }

  

public class YaoGuai
    {
        public int Blood { get; private set; }

        public YaoGuai(int blood)
        {
            Blood = blood;
            Console.WriteLine($"我是妖怪,我有{Blood}滴血!");
        }

        public void BeAttacked(int attack)
        {
            if (Blood > 0)
            {
                Blood = Blood - attack;
                if (Blood < 0)
                {
                    Blood = 0;
                }
            }
            Console.WriteLine($"我是妖怪,我剩余{Blood}滴血!");
        }
    }

  

 class Program
    {
        static void Main(string[] args)
        {
            YaoGuai yaoGuai = new YaoGuai(1000);
            Player p1 = new Player("孙悟空", 300);
            Player p2 = new Player("猪八戒", 180);

            Thread t1 = new Thread(() => { p1.Attack(yaoGuai); });
            Thread t2 = new Thread(() => { p2.Attack(yaoGuai); });
            t1.Start();
            t2.Start();
            t1.Join();
            t2.Join();

            Console.WriteLine("===============================");

            YaoGuai yaoGuai2 = new YaoGuai(1000);
            PlayerWithMonitor p3 = new PlayerWithMonitor("孙悟空", 300);
            PlayerWithMonitor p4 = new PlayerWithMonitor("猪八戒", 180);

            Thread t3 = new Thread(() => { p3.Attack(yaoGuai2); });
            Thread t4 = new Thread(() => { p4.Attack(yaoGuai2); });
            t3.Start();
            t4.Start();
            t3.Join();
            t4.Join();

            Console.ReadKey();
        }
    }

  

标签:Console,Name,Thread,C#,基础,t1,线程,new,public
来源: https://www.cnblogs.com/sunliyuan/p/12992701.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有