C#多线程开发-线程同步 02

简介: C#多线程开发-线程同步 02

上一篇文章主要带领大家认识了线程,也了解到了线程的基本用法和状态,接下来就让我们一起学习下什么是线程同步。


线程中异常的处理


在线程中始终使用try/catch代码块是非常重要的,因为不可能在线程代码之外来捕获到异常。



可以阅读下面的代码,这块是做的验证,证明在线程之外捕获异常是错误的选择,应该在线程中时时刻刻都使用异常处理机制。


   static void Main(string[] args)
        {
            Thread twoThread = new Thread(TwoMethod);
            twoThread.Start();
            twoThread.Join();            
            try
            {
                Thread oneThread = new Thread(OneMethod);
                oneThread.Start();
            }
            catch (Exception ex)
            {
                Console.WriteLine("外部捕获线程one的异常:"+ex.Message);
            }            
            Console.ReadKey();
        }
        static void OneMethod() 
        {
            Console.WriteLine("Start OneMethod");
            Thread.Sleep(TimeSpan.FromSeconds(2));
            throw new Exception("异常01");
        }
        static void TwoMethod() 
        {
            try
            {
                Console.WriteLine("Start TwoMethod");
                Thread.Sleep(TimeSpan.FromSeconds(1));
                throw new Exception("异常02");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);                
            }
        }


下面图片是输出报错的结果,可以看到OneThread的异常没有被外部的try/catch捕获到,导致直接在线程内部提示错误,导致程序崩溃。



看到这个情况,那么我们在以后使用线程的时候,就需要特别的注意,一定要在线程中进行异常的处理和捕获,千万别遗留任何未处理的异常,因为如果线程中有未被处理的异常会导致整个程序都会受到影响,可能导致整个软件崩溃。


线程同步



在上一篇推文中,我们了解到了Lock加锁的机制,它是可以保证将某个变量或者某个模块锁住,当出现多个线程同时访问时锁就会起作用,只允许一个线程访问,其余的等待,其访问完后其余的才可以进行访问。


但是这种机制有一定的局限性,在多核CPU设备中,让其余线程等待是极大浪费资源的,而且这种解决办法会导致死锁的现象。



上面说的也就是所谓的竞争条件问题的解决方法,导致这个问题的原因是多线程的执行并没有正确同步。当一个线程执行递增和递减操作时,其他线程需要依次等待。这种常见问题通常被称为线程同步。这种问题出现在当线程中有共享资源或者对象时,才会进行线程同步,如果无共享对象,则无需进行线程同步。


当在线程中有共享资源时,可使用下面的两种方式进行处理。


一、原子操作


来实现对共享资源的访问。其实就是一个操作只占用一个量子的时间,一次就可以完成。也就是说只有当前操作完成后,其他线程才能执行其他操作。这样就避免了使用锁,排除了死锁的情况。


原子操作就是使用C#系统自带的Interlocked类来对线程不安全的对象进行处理,借助Interlocked类,无需锁定任何对象即可获取到正确的结果,Interlocked类提供Increment,Decrement和Add等基本数学操作的原子方法,从而可以帮助我们无需使用锁🔒,避免出现各种死锁问题。


/// <summary>
    /// 线程不安全
    /// </summary>
    class Counter
    {
        private int _count;
        public int Count { get { return _count; } }
        public void Add() 
        {
            _count++;
        }
        public void Delete() 
        {
            _count--;
        }
    }


 /// <summary>
    /// 不加锁 ,但线程是安全的。
    /// 可避免在线程中出现死锁
    /// </summary>
    class CounterNoLock 
    {
        private int _count;
        public int Count { get { return _count; } }
        public void Add()
        {
            Interlocked.Increment(ref _count);          //递增
        }
        public void Delete()
        {
            Interlocked.Decrement(ref _count);          //递减
        }
    }


二、将等待的线程置于阻塞状态


这个处理方法是在第一个原子操作无效切程序的逻辑更加复杂的情况下才使用的,用于协调线程。


当线程处理阻塞状态时,只会占用尽可能少的CPU时间,这就意味着将引入至少一次所谓的上下文切换


上下文切换:指操作系统的线程调度器,该调度器会保持等待的线程的状态,并切换到另一个线程,依次恢复等待的线程状态。虽然会消耗极大的资源,但是如果线程被挂起很长时间这么做是值得的。这种也就内核模式,因为只有操作系统的内核才能阻止线程使用CPU时间。


用户模式: 如果线程只是等候一小会,那最好只是简单的等待,而不用将线程切换到阻塞状态。还有一种为混合模式,也就是先尝试使用用户模式,如果线程等候时间过长,则会切换到阻塞状态以节省CPU资源。


下面的DEMO主要介绍SemaphoreSlim类,该类用于限制了同时访问同一个资源的线程数量。


     static void Main(string[] args)
        {   
            for (int i = 1; i <=6; i++)
            {
                string threadName = "Thread " + i;
                int secondsWait = 2;
                var thread = new Thread(( )=>DataConnect(threadName,secondsWait));
                thread.Start();
            }
            Console.ReadKey();
        }
        static SemaphoreSlim _semaphore = new SemaphoreSlim(4);             //默认4个线程可同时访问
        static void DataConnect(string name,int seconds) 
        {
            Console.WriteLine("wait 线程的名字:",name);
            _semaphore.Wait();
            Console.WriteLine("Connect 线程的名字:" + name);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            _semaphore.Release();
        }


上面的代码利用SemaphoreSlim类,设置其构造函数为4,也就是其指定允许的并发线程数量。


上面使用信号系统限制了访问数据连接的并发数为4个,当有4个线程进行访问时,其他两个线程需要等待,知道之前线程中某一个完成工作并调用Relece方法来发出信号。


目录
相关文章
|
6天前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
13天前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
74 10
spring多线程实现+合理设置最大线程数和核心线程数
|
22天前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android多线程编程的重要性及其实现方法,涵盖了基本概念、常见线程类型(如主线程、工作线程)以及多种多线程实现方式(如`Thread`、`HandlerThread`、`Executors`、Kotlin协程等)。通过合理的多线程管理,可大幅提升应用性能和用户体验。
37 15
一个Android App最少有几个线程?实现多线程的方式有哪些?
|
7天前
|
Python
5-5|python开启多线程入口必须在main,从python线程(而不是main线程)启动pyQt线程有什么坏处?...
5-5|python开启多线程入口必须在main,从python线程(而不是main线程)启动pyQt线程有什么坏处?...
|
24天前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android应用开发中的多线程编程,涵盖基本概念、常见实现方式及最佳实践。主要内容包括主线程与工作线程的作用、多线程的多种实现方法(如 `Thread`、`HandlerThread`、`Executors` 和 Kotlin 协程),以及如何避免内存泄漏和合理使用线程池。通过有效的多线程管理,可以显著提升应用性能和用户体验。
38 10
|
22天前
|
API Android开发 iOS开发
安卓与iOS开发中的线程管理对比
【9月更文挑战第12天】在移动应用的世界中,安卓和iOS平台各自拥有庞大的用户群体。开发者们在这两个平台上构建应用时,线程管理是他们必须面对的关键挑战之一。本文将深入探讨两大平台在线程管理方面的异同,通过直观的代码示例,揭示它们各自的设计理念和实现方式,帮助读者更好地理解如何在安卓与iOS开发中高效地处理多线程任务。
|
4天前
|
NoSQL 网络协议 Unix
1)Redis 属于单线程还是多线程?不同版本之间有什么区别?
1)Redis 属于单线程还是多线程?不同版本之间有什么区别?
14 0
|
6天前
|
Java
COMATE插件实现使用线程池高级并发模型简化多线程编程
本文介绍了COMATE插件的使用,该插件通过线程池实现高级并发模型,简化了多线程编程的过程,并提供了生成结果和代码参考。
|
16天前
|
安全 数据库连接 API
C#一分钟浅谈:多线程编程入门
在现代软件开发中,多线程编程对于提升程序响应性和执行效率至关重要。本文从基础概念入手,详细探讨了C#中的多线程技术,包括线程创建、管理及常见问题的解决策略,如线程安全、死锁和资源泄露等,并通过具体示例帮助读者理解和应用这些技巧,适合初学者快速掌握C#多线程编程。
49 0
|
2月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
64 1