C# 线程同步

最新推荐文章于 2025-08-09 18:35:14 发布
转载 最新推荐文章于 2025-08-09 18:35:14 发布 · 77 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/ch-lf/p/5713917.html
文章标签：

#操作系统 #数据库

概念简介

线程同步

  • 当一个线程执行递增和递减操作时，其他线程需要依次次等待，这种问题通常被称为线程同步。
###原子操作
  • 一个操作只占用一个量子的时间，一次就可以完成。
###阻塞状态(内核模式)

  • 讲等待的线程置于阻塞状态，当线程处于阻塞状态时，只会占用尽量少的CPU时间。然而这样就会引入至少一次所谓的上下文切换。上下文切换是指操作系统的线程调度器。该调度器会保存等待的线程的状态，并切换另一个线程，一次恢复等待的线程状态。这需要消耗相当多的资源。然而如果线程要被挂起很长时间，那么这么做是值得的。这种方式又被称为内核模式。因为只有操作系统的内核才能阻止线程使用ＣＰＵ时间。

    用户模式

  • 万一线程只需要等待一小段时间，最好只是简单的等待，而不用将线程切换到阻塞状态。虽然线程等待依然会浪费CPU时间。但我们节省了上下文切换耗费的CPU时间。该方式被称为用户模式，该方式非常轻量，速度很快，但如果线程需要等待较长时间则会浪费大量的CPU时间。

###混合模式
  • 混合模式是内核模式和用户模式的混合，混合模式先尝试使用用户模式等待，如果线程等待了足够长的时间，则切换到阻塞状态（即内核模式）以节省CPU资源

原子操作



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace testThread_atom
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Incorrect counter");
            var c = new Counter();
            var t1 = new Thread(()=>testcounter(c));
            var t2 = new Thread(() => testcounter(c));
            var t3 = new Thread(() => testcounter(c));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();
            Console.WriteLine("Total Counter:{0}",c.counter);
            Console.WriteLine("--------------------------");
            Console.WriteLine("Correct counter");

            var c1 = new CounterWithNolock();
            t1 = new Thread(() => testcounter(c1));
            t2 = new Thread(() => testcounter(c1));
            t3 = new Thread(() => testcounter(c1));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();
            Console.WriteLine("Total Counter:{0}",c1.Counter);
        }
        static void testcounter(CounterBase c)
        {
            for (int i = 0; i < 10000; i++)
            {
                c.Increment();
                c.Decrement();
            }
        }
    }
    abstract class CounterBase
    {
        public abstract void Increment();
        public abstract void Decrement();
    }
    class Counter : CounterBase
    {
        private int _counter;
        public int counter { get { return _counter; } }
        public override void Increment()
        {
            _counter++;
        }
        public override void Decrement()
        {
            _counter--;
        }
    }
    class CounterWithNolock : CounterBase
    {
        private int _counter;
        public int Counter { get { return _counter; } }
        public override void Increment()
        {
            Interlocked.Increment(ref _counter);
        }
        public override void Decrement()
        {
            Interlocked.Decrement(ref _counter);
        }
    }
}
  • 结果

998935-20160728105028575-1262473536.png

使用Mutex类

  • Mutex是一种原始的同步方式。其只是一个对线程授予对共享资源的独自访问。

  • 实例

              static void Main(string[] args)
        {
            const string MutexName = "CsharpThreadingCookBook";
            using(var m=new Mutex(false,MutexName))
            {
                if (!m.WaitOne(TimeSpan.FromSeconds(5), false))
                {
                    Console.WriteLine("Second instance is running");
                    Console.ReadLine();
                }
                else
                {
                    Console.WriteLine("Running!");
                    Console.ReadLine();
                    m.ReleaseMutex();
                }
            }
        }

  • 结果
    当程序启动时，定义了一个指定名称的互斥量，设置initalOwner标志为false。这意味着如果互斥量已经被创建，则允许程序获取该互斥量。如果没有获取互斥量，程序则简单的显示running，等待直到按下了任何键，然后释放该互斥量并退出。
    如果再运行同样一个程序，则会5S内尝试获取互斥量。如果此时在第一个程序中按下任何键，第二个程序则会开始执行。然而如果保持等待5S第二个程序将无法获取到改互斥量。

    第一个程序没有按键
    998935-20160728142955059-1554816789.png
    第一个程序按键 第二个程序显示依然是running
    998935-20160728143120763-559076779.png

SemaphoreSlim 类

 class Program
    {
        static SemaphoreSlim _semphore = new SemaphoreSlim(2);
        static void Main(string[] args)
        {
            for (int i = 1; i <= 6; i++)
            {
                string threadname = "Thread" + i;
                int secondtowait = 2 + 2 * i;
                var t = new Thread(()=>accessdatabase(threadname,secondtowait));
                t.Start();
            
            }
        }
        static void accessdatabase(string name,int seconds)
        {
            Console.WriteLine("{0} waits access a database",name);
            _semphore.Wait();
            Console.WriteLine("{0} was granted an access to a database",name);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine("{0} is Completed",name);
            _semphore.Release();
         }
    }
  • 结果
    998935-20160728145401794-39615047.png

使用AutoResetEvent类


   class Program
    {
        private static AutoResetEvent _workevent = new AutoResetEvent(false);
        private static AutoResetEvent _mainevent = new AutoResetEvent(false);
        static void Main(string[] args)
        {
            var t = new Thread(()=>process(10));
            t.Start();

            Console.WriteLine("waiting for another thread to complete work");
            _workevent.WaitOne();
            Console.WriteLine(" first operation is completed");
            Console.WriteLine(" performing an operation on a main thread");
            Thread.Sleep(TimeSpan.FromSeconds(5));
            _mainevent.Set();
            Console.WriteLine("Now running the second operation on a second thread");
            _workevent.WaitOne();
            Console.WriteLine("second operation is completed");
        }
        static void process(int seconds)
        {
            Console.WriteLine("starting a long running work");
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine("work is done");
            _workevent.Set();

            Console.WriteLine("waiting for a main thread to complete its work ");
            _mainevent.WaitOne();
            Console.WriteLine("starting second operation");
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine("work is done");
            _workevent.Set();

        }
    }
  • 结果
![](http://images2015.cnblogs.com/blog/998935/201607/998935-20160728153622934-1588348280.png)

使用ManualResetEventSlim类


    class Program
    {
        static ManualResetEventSlim _mainevent = new ManualResetEventSlim(false);
        static void Main(string[] args)
        {
            var t1 = new Thread(() => TravelThroughGates("Thread 1",5));
            var t2 = new Thread(() => TravelThroughGates("Thread 2", 6));
            var t3 = new Thread(() => TravelThroughGates("Thread 3", 12));
            t1.Start();
            t2.Start();
            t3.Start();
            Thread.Sleep(TimeSpan.FromSeconds(6));

            Console.WriteLine("the gates are now open");
            _mainevent.Set();
            Console.WriteLine("the gates have been closed");
            Thread.Sleep(TimeSpan.FromSeconds(10));
            Console.WriteLine("the gates are now open for second time");
            _mainevent.Set();
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Console.WriteLine("the gates have been closed");
            _mainevent.Reset();
            Console.ReadLine();

        }
        static void TravelThroughGates(string threadname,int seconds)
        {
            Console.WriteLine("{0} fails to sleep",threadname);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));

            Console.WriteLine("{0} waits for the gates to open ",threadname);
            _mainevent.Wait();
            Console.WriteLine("{0} enters the gates",threadname);
        }
    }
  • 结果

998935-20160728170842528-1685082823.png

转载于:https://www.cnblogs.com/ch-lf/p/5713917.html

c# 多线程创建及线程同步
baidu_16370559的博客
03-08 1229
BeginInvoke倒数第二个参数(MethodCompleted)是回调方法委托类型，他是回调方法的委托，此委托没有返回值，有一个IAsyncResult类型的参数，当method方法执行完后，系统会自动调用MethodCompleted方法。ManualResetEvent：在调用 `Set` 方法后，所有等待线程都会被唤醒并继续执行，直到显式调用 `Reset` 方法将 ManualResetEvent 设置回无信号状态为止。即每次调用 `Set` 方法会唤醒所有等待线程。
【C#】38. 线程的等待方法：join
huiwuhuiwu的专栏
12-11 6522
其实多线程最复杂的地方在于不同线程间的同步问题，这其中会涉及到先后执行问题、共享变量问题等。这篇文章我们主要来开个头，看一下join方法。 using System; using System.Threading; namespace Chapter1.Recipe3 { class Program { static void Main(string[] args) { Console.Wri
c# 多线程等待同步
把梦想放飞在蓝色的天空里...
09-24 921
目的： 多个按钮点击新建线程执行某个任务。实现多线程执行任务，总数不超过某个数值，超过则等待执行完成才可以再次点击。 编程思路： 使用原子锁计算当前线程总数、线程Join 等待执行完毕。 public class test { ... private int threadCount = 0; //当前线程总数 private int maxT...
C#多线程同步事件及等待句柄
热门推荐
wangqiuyun的专栏
10-29 3万+
最近捣鼓了一下多线程的同步问题，发现其实C#关于多线程同步事件处理还是很灵活，这里主要写一下，自己测试的一些代码，涉及到了AutoResetEvent 和 ManualResetEvent，当然还有也简要提了一下System.Threading.WaitHandle.WaitOne 、System.Threading.WaitHandle.WaitAny和System.Threading.Wait
多线程：C#线程同步lock,Monitor,Mutex,同步事件和等待句柄（下）
jackyxu_2008的专栏
04-20 1457
http://www.cnblogs.com/freshman0216/archive/2008/08/07/1256919.html 前两篇简单介绍了线程同步lock，Monitor，同步事件EventWaitHandler，互斥体Mutex的基本用法，在此基础上，我们对它们用法进行比较，并给出什么时候需要锁什么时候不需要的几点建议。最后，介绍几个FCL中线程安全的类，集合类的锁定方式等
C# 多线程(lock,Monitor,Mutex,同步事件和等待句柄)
weixin_34269583的博客
04-02 387
本篇从 Monitor，Mutex，ManualResetEvent，AutoResetEvent，WaitHandler 的类关系图开始，希望通过本篇的介绍能对常见的线程同步方法有一个整体的认识，而对每种方式的使用细节，适用场合不会过多解释。 让我们来看看这几个类的关系图： 1. lock 关键字     lock 是 C# 关键词，它将语句块标记为临界区,确保当一个线程位于...
Win10还未停更，对标iPad的教育版Win11也宣布停更了
meiyimin的专栏
08-06 241
无论是 Copilot 的深度整合，还是下一代硬件中 NPU（神经处理单元）的逐步标配，微软对 Windows 的未来定义已经越来越明确：不是“再造多个系统版本”，而是围绕一个智能核心，打通用户体验。然而，这样的系统虽然目标明确，却始终没有获得太多市场热情。微软试图与 Google 的 ChromeOS 和苹果的 iPad 争夺教育市场，但现实中，后两者的占有率和生态优势早已稳固，加之微软自身硬件和 OEM 合作的局限，Windows 11 SE 并未真正撼动教育设备的主流格局。
海康威视摄像头实时推流到阿里云公网服务器（Windows + FFmpeg + nginx-rtmp)
最新发布
willem的博客
08-09 543
摘要： 本文详细介绍将海康威视摄像头视频流通过Windows电脑推送到阿里云服务器的完整方案。步骤包括：1）在阿里云ECS部署nginx-rtmp服务并开放端口；2）Windows端安装FFmpeg，通过RTSP拉取摄像头流并转推RTMP协议；3）使用VLC或网页进行公网播放验证；4）通过nssm工具将推流程序注册为Windows服务实现长期运行。方案支持低延迟传输，提供常见问题排查方法和一键脚本，适用于7×24小时监控场景，最终实现公网多终端访问摄像头视频流。
搭建私有 Linux 镜像仓库
qq_31292011的博客
08-06 469
统一管理软件包版本，确保环境一致性。：减少外网带宽消耗，提升下载速度。：减少重复下载，节省带宽成本。：内网环境下的安全软件分发。：支持无外网环境的软件安装。
Linux系统Ansible之Playbook简单应用
2503_91960880的博客
08-06 907
playbook是ansible用于配置，部署和管理托管主机剧本，通过playbook的详细描述，执行其中一系列tasks，可以让远程主机达到预期状态，也可以说，playbook字面意思是剧本，现实中由演员按剧本表演，在ansible中由计算机进行安装，部署应用，提供对外服务，以及组织计算机处理各种各样的事情。ansible使用playbook来管理自动化task，playbook是yaml格式的文件，其基本内容可以认为是多条ansible的ad-hoc的语句组成。
RAGFlow系列（06）：升级到0.20.0版本的详细操作步骤
持之以恒
08-07 401
RAGFlow升级到0.20.0版本的具体操作步骤
MySQL 极简安装挑战：跨平台高效部署指南
一名梦想用科技与数学改变人类的世界的人
08-07 1090
本文介绍了MySQL数据库的极简安装与部署方法，涵盖Linux、Windows和macOS三大平台。核心原则包括最小化安装必要组件、采用无交互命令行模式、实施安全基线配置。详细说明了各平台的具体安装步骤：Linux环境通过自动化脚本实现快速部署，Windows采用免安装ZIP包方式，macOS则使用Homebrew简化安装流程。文章还强调了安全加固措施，如强化密码策略、控制远程访问、开启日志审计等，并提供了性能测试和常见问题解决方法。整套方案旨在实现MySQL的高效、安全部署，适用于生产环境和开发测试场景。
linux centos安装python3.13
hzp666的博客
08-08 141
sudo make altinstall # 重要：使用 altinstall 避免覆盖系统Python。make -j $(nproc) # 使用所有CPU核心加速编译。# 3. 配置和编译（安装到 /usr/local）# 2. 下载 Python 3.13 源码。# 应显示：Python 3.13.0。# 1. 安装编译依赖。
脱机部署k3s
KawYang的博客
08-07 260
（K3s 离线镜像包）k3s-arm64（K3s 二进制文件）nginx.tar（需要导入的镜像文件，示例中为 nginx）
Python：文件管理
2401_87353862的博客
08-06 812
在计算机中，文件是具有符号名的、在逻辑上具有完整意义的一组相关信息项的有序序列。从代码的角度来看，文件是存储在磁盘或其他存储设备上的数据集合，可以通过编程接口（如 Python 中的open()函数）进行读取和写入操作。文件路径是文件在文件系统中的位置标识，用于准确定位和访问存储设备上的文件。
Java学习第一百一十五部分——Meilisearch
2503_92550335的博客
08-08 338
Meilisearch是一款开源的实时全文搜索引擎，专为速度、易用性和开发者体验设计。本文介绍其架构优势，适用场景，最佳实践等内容。
IB升级固件版本和升级驱动失败原因及解决故障
风是自由的，你也是
08-08 135
摘要： 用户从23版本升级Mellanox驱动时失败，执行ibstat和mst start命令无响应。直接安装24.10版本驱动仍失败，日志显示依赖包缺失但无明确报错。通过分析发现IB驱动丢失，最终通过重新安装23版本驱动后再升级至24.10版本，成功解决问题。关键步骤为修复底层驱动后再执行版本升级。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值