- 浏览: 661776 次
- 性别:
- 来自: 石家庄
文章分类
最新评论
-
abao1:
老贾 在安装IDEA的过程中,在激活步骤时,按如下操作即可: ...
IntelliJ IDEA 2016注册方法和注册码 -
bo_hai:
./usr/bin/java: symbol lookup ...
jmagick安装步骤 -
wxcking:
不错的, 收藏一下
JAVA使用POI生成Excel文件 -
zgyfh:
大哥,密码是多少啊?zgyfh@tom.com谢谢了!新手学习 ...
WPF做的必备示例 -
记忆无泪:
jiasongmao 写道你的邮箱是多少,我可以发源代码到邮箱 ...
WPF做的必备示例
在多线程中,为了使数据保持一致性必须要对数据或是访问数据的函数加锁,在数据库中这是很常见的,但是在程序中由于大部分都是单线程的程序,所以没有加锁的必要,但是在多线程中,为了保持数据的同步,一定要加锁,好在Framework中已经为我们提供了三个加锁的机制,分别是Monitor类、Lock关键字和Mutex类。
其中Lock关键词用法比较简单,Monitor类和Lock的用法差不多。这两个都是锁定数据或是锁定被调用的函数。而Mutex则多用于锁定多线程间的同步调用。简单的说,Monitor和Lock多用于锁定被调用端,而Mutex则多用锁定调用端。
例如下面程序:由于这种程序都是毫秒级的,所以运行下面的程序可能在不同的机器上有不同的结果,在同一台机器上不同时刻运行也有不同的结果,我的测试环境为vs2005, windowsXp , CPU3.0 , 1 G monery。
程序中有两个线程thread1、thread2和一个TestFunc函数,TestFunc会打印出调用它的线程名和调用的时间(mm级的),两个线程分别以30mm和100mm来调用TestFunc这个函数。TestFunc执行的时间为50mm。程序如下:
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace MonitorLockMutex
{
class Program
{
#region variable
Thread thread1 = null;
Thread thread2 = null;
Mutex mutex = null;
#endregion
static void Main(string[] args)
{
Program p = new Program();
p.RunThread();
Console.ReadLine();
}
public Program()
{
mutex = new Mutex();
thread1 = new Thread(new ThreadStart(thread1Func));
thread2 = new Thread(new ThreadStart(thread2Func));
}
public void RunThread()
{
thread1.Start();
thread2.Start();
}
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
TestFunc("Thread1 have run " + count.ToString() + " times");
Thread.Sleep(30);
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
TestFunc("Thread2 have run " + count.ToString() + " times");
Thread.Sleep(100);
}
}
private void TestFunc(string str)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
}
}
运行结果如下: 可以看出如果不加锁的话,这两个线程基本上是按照各自的时间间隔+TestFunc的执行时间(50mm)对TestFunc函数进行读取。因为线程在开始时需要分配内存,所以第0次的调用不准确,从第1~9次的调用可以看出,thread1的执行间隔约是80mm,thread2的执行间隔约是150mm。
现在将TestFunc修改如下:
private void TestFunc(string str)
{
lock (this)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
}
或者是用Monitor也是一样的,如下:
private void TestFunc(string str)
{
Monitor.Enter(this);
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
Monitor.Exit(this);
}
其中Enter和Exit都是Monitor中的静态方法。
运行Lock结果如下: 让我们分析一下结果,同样从第1次开始。相同线程间的调用时间间隔为线程执行时间+TestFunc调用时间,不同线程间的调用时间间隔为TestFunc调用时间。例如:连续两次调用thread1之间的时间间隔约为30+50=80;连续两次调用thread2之间的时间间隔约为100+50=150mm。调用thread1和thread2之间的时间间隔为50mm。因为TestFunc被lock住了,所以一个thread调用TestFunc后,当其它的线程也同时调用TestFunc时,后来的线程即进被排到等待队列中等待,直到拥有访问权的线程释放这个资源为止。
这就是锁定被调用函数的特性,即只能保证每次被一个线程调用,线程优先级高的调用的次数就多,低的就少,这就是所谓的强占式。
下面让我们看看Mutex类的使用方法,以及与Monitor和Lock的区别。
将代码修改如下:
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
mutex.WaitOne();
TestFunc("Thread1 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
mutex.WaitOne();
TestFunc("Thread2 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
private void TestFunc(string str)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
运行结果如下:
可以看出,Mutex只能互斥线程间的调用,但是不能互斥本线程的重复调用,即thread1中waitOne()只对thread2中的waitOne()起到互斥的作用,但是thread1并不受本wainOne()的影响,可以调用多次,只是在调用结束后调用相同次数的ReleaseMutex()就可以了。
那么如何使线程按照调用顺序来依次执行呢?其实把lock和Mutex结合起来使用就可以了,改代码如下:
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
lock (this)
{
mutex.WaitOne();
TestFunc("Thread1 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
lock (this)
{
mutex.WaitOne();
TestFunc("Thread2 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
}
转载地址:http://hi.baidu.com/zeratul_bb/blog/item/84e7b602dab6eb084bfb515c.html
其中Lock关键词用法比较简单,Monitor类和Lock的用法差不多。这两个都是锁定数据或是锁定被调用的函数。而Mutex则多用于锁定多线程间的同步调用。简单的说,Monitor和Lock多用于锁定被调用端,而Mutex则多用锁定调用端。
例如下面程序:由于这种程序都是毫秒级的,所以运行下面的程序可能在不同的机器上有不同的结果,在同一台机器上不同时刻运行也有不同的结果,我的测试环境为vs2005, windowsXp , CPU3.0 , 1 G monery。
程序中有两个线程thread1、thread2和一个TestFunc函数,TestFunc会打印出调用它的线程名和调用的时间(mm级的),两个线程分别以30mm和100mm来调用TestFunc这个函数。TestFunc执行的时间为50mm。程序如下:
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace MonitorLockMutex
{
class Program
{
#region variable
Thread thread1 = null;
Thread thread2 = null;
Mutex mutex = null;
#endregion
static void Main(string[] args)
{
Program p = new Program();
p.RunThread();
Console.ReadLine();
}
public Program()
{
mutex = new Mutex();
thread1 = new Thread(new ThreadStart(thread1Func));
thread2 = new Thread(new ThreadStart(thread2Func));
}
public void RunThread()
{
thread1.Start();
thread2.Start();
}
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
TestFunc("Thread1 have run " + count.ToString() + " times");
Thread.Sleep(30);
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
TestFunc("Thread2 have run " + count.ToString() + " times");
Thread.Sleep(100);
}
}
private void TestFunc(string str)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
}
}
运行结果如下: 可以看出如果不加锁的话,这两个线程基本上是按照各自的时间间隔+TestFunc的执行时间(50mm)对TestFunc函数进行读取。因为线程在开始时需要分配内存,所以第0次的调用不准确,从第1~9次的调用可以看出,thread1的执行间隔约是80mm,thread2的执行间隔约是150mm。
现在将TestFunc修改如下:
private void TestFunc(string str)
{
lock (this)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
}
或者是用Monitor也是一样的,如下:
private void TestFunc(string str)
{
Monitor.Enter(this);
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
Monitor.Exit(this);
}
其中Enter和Exit都是Monitor中的静态方法。
运行Lock结果如下: 让我们分析一下结果,同样从第1次开始。相同线程间的调用时间间隔为线程执行时间+TestFunc调用时间,不同线程间的调用时间间隔为TestFunc调用时间。例如:连续两次调用thread1之间的时间间隔约为30+50=80;连续两次调用thread2之间的时间间隔约为100+50=150mm。调用thread1和thread2之间的时间间隔为50mm。因为TestFunc被lock住了,所以一个thread调用TestFunc后,当其它的线程也同时调用TestFunc时,后来的线程即进被排到等待队列中等待,直到拥有访问权的线程释放这个资源为止。
这就是锁定被调用函数的特性,即只能保证每次被一个线程调用,线程优先级高的调用的次数就多,低的就少,这就是所谓的强占式。
下面让我们看看Mutex类的使用方法,以及与Monitor和Lock的区别。
将代码修改如下:
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
mutex.WaitOne();
TestFunc("Thread1 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
mutex.WaitOne();
TestFunc("Thread2 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
private void TestFunc(string str)
{
Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
Thread.Sleep(50);
}
运行结果如下:
可以看出,Mutex只能互斥线程间的调用,但是不能互斥本线程的重复调用,即thread1中waitOne()只对thread2中的waitOne()起到互斥的作用,但是thread1并不受本wainOne()的影响,可以调用多次,只是在调用结束后调用相同次数的ReleaseMutex()就可以了。
那么如何使线程按照调用顺序来依次执行呢?其实把lock和Mutex结合起来使用就可以了,改代码如下:
private void thread1Func()
{
for (int count = 0; count < 10; count++)
{
lock (this)
{
mutex.WaitOne();
TestFunc("Thread1 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
}
private void thread2Func()
{
for (int count = 0; count < 10; count++)
{
lock (this)
{
mutex.WaitOne();
TestFunc("Thread2 have run " + count.ToString() + " times");
mutex.ReleaseMutex();
}
}
}
转载地址:http://hi.baidu.com/zeratul_bb/blog/item/84e7b602dab6eb084bfb515c.html
发表评论
-
美了哭了,AduSkin是我见过最好看的WPF控件库
2020-03-14 19:58 644原文地址:https://www.pianshen.com/ ... -
使用NSSM把.Net Core部署至 Windows 服务
2019-10-16 08:52 523转自:https://www.cnblogs.com/emr ... -
玩转ASP.NET Core中的日志组件
2019-01-06 16:11 688转自:https://www.cnblogs.com/ ... -
CentOS 7 部署 ASP.NET Core 应用程序
2019-01-04 13:56 497CentOS 7 部署 ASP.NET Core 应用程序 ... -
GeckoWebBrowser实现自定义打印
2018-12-22 00:26 783nsIWebBrowserPrint print ... -
Winform桌面程序如何使用Geckofx45
2018-12-05 14:50 2345NuGet管理GeckoFx PM> Inst ... -
NLog的介绍使用
2018-09-28 17:36 1062NLog是什么 NLog是一个基于.NET平台编写的类库, ... -
常用的.net开源项目
2018-09-28 17:01 452常用 Json.NET:Json.Net ... -
高效实用的.NET开源项目
2018-09-28 16:58 4791.Akka.NET: 概述:更轻松地构建强大的并发 ... -
OCR框架整理
2017-08-16 09:29 568泰比ABBYY OCR SDK开发包 Asp ... -
使用Aspose.word导出word报告
2017-04-09 11:49 1614最近在做一个.net项目需要实现网站导出word报告功能,最 ... -
利用Aspose.Words 完美生成word试卷
2017-04-09 11:43 5249aspose.word生成word文档 public cl ... -
java使用wsimport生成服务代码时报错的解决办法
2017-01-18 11:27 1677今天遇到了WebService的问题:在使用jdk命令wsi ... -
OCR文字识别系统
2016-12-21 22:14 410慧视OCR文字识别系统 增值税专用发票扫描识别系统 ... -
asprise-ocr:验证码识别
2016-12-21 22:17 737asprise-ocr http://asprise ... -
jieba中文分词的.NET版本:jieba.NET
2015-09-10 09:36 790转自:http://www.cnblogs.com/ande ... -
通用身份验证类:AuthenticationCookie
2015-09-06 09:00 712/// <summary> /// C ... -
KwCombinatorics排列组合类库
2015-08-06 17:34 598KwCombinatorics类库的主页是:http: ... -
CefSharp嵌入式浏览器
2015-08-06 15:21 1038日常开发中,我们需要将一些Web页面嵌入到桌面客户端软件中。 ... -
C#开源框架(整理)
2015-07-27 09:32 2342http://www.cnblogs.com/c ...
相关推荐
C#中使用MONITOR类LOCK和MUTEX类来同步多线程的执行[归纳].pdf
5. 资源竞争和线程安全:资源竞争是多线程中常见的问题,通过同步机制可以保证线程安全,即在多线程环境中,对共享资源的访问不会导致数据不一致或其他问题。 以上知识为我们理解在.NET环境中如何使用Monitor类、...
`Monitor`类、`Lock`关键字(实际上是`System.Threading.Monitor`的隐式使用)和`Mutex`类提供了三种不同的机制来实现这一目标。让我们详细探讨它们的用法和区别。 1. **Monitor类**: `Monitor`类提供了对对象的...
C#提供了多种机制来实现线程同步,包括lock关键字、Monitor、同步事件和等待句柄以及Mutex类。这些机制的主要目标是避免竞态条件,保证并发执行的线程能够正确地访问和修改共享数据。 首先,我们来看lock关键字。...
多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄[整理].pdf
为了保护应用程序的资源不被破坏,为多线程程序提供了三种加锁的机制,分别是:Monitor类、Lock关键字和Mutex类。 1. lock lock实现的功能是:使后进入的线程不会中断当前的线程,而是等待当前线程结束后再继续执行...
这个项目的源代码可能包含了如何在C#中使用多线程和同步锁与SQLite交互的示例。通常,它会展示如何在多个线程中并行执行读写操作,以及如何使用`lock`或其他同步原语来保护对数据库的访问。测试部分可能会比较不同...
在C#中,多线程可以通过多种方式实现,包括但不限于使用`Thread`类、`Task`类以及`async/await`关键字。在给定的部分代码中,我们主要探讨了通过`Thread`类来实现多线程,以及如何处理线程间的同步问题,避免数据...
C#提供了一些同步机制,如Mutex、Semaphore、Monitor和锁(lock关键字),来确保对共享资源的访问是线程安全的。例如,使用lock关键字可以防止数据竞争: ```csharp lock (someObject) { // 访问共享资源的代码 } ...
在C#编程中,`Lock`是一个至关重要的概念,它涉及到多线程编程中的同步控制。`Lock`机制用于确保在任何给定时间只有一个线程可以访问特定的代码块,从而避免了数据竞争和其他并发问题。这个实例将深入探讨`Lock`的...
在编程领域,多线程是实现并发执行任务的关键技术,特别是在UI应用如Windows Presentation Foundation (WPF) 中,多线程能有效提升程序的响应性和性能。本文将深入探讨C#中的多线程机制,包括线程互斥与同步,以及...
在实际的多线程应用中,除了`lock`,还可以使用`Monitor`、`Mutex`、`Semaphore`等其他同步机制来实现互斥和资源限制。例如,`Mutex`允许跨进程的互斥访问,而`Semaphore`则可以控制同时访问资源的线程数量。 测试...
在单线程环境下,程序按顺序执行任务,而在多线程中,程序可以同时执行多个任务。创建新线程通常通过`System.Threading.Thread`类实现,通过`Start`方法启动线程。然而,频繁创建和销毁线程会带来性能开销,因此推荐...
然而,需要注意的是,过度使用`lock`可能导致死锁和性能下降,因此在编写多线程代码时,应尽量减少锁的使用,并考虑其他同步机制,如`Monitor`、`Mutex`、`Semaphore`或`Interlocked`类,根据具体场景选择最适合的...
在C#编程中,多线程是一个核心概念,它允许程序同时执行多个任务,从而提高应用程序的效率和响应性。System.Threading命名空间中的Thread类是实现多线程的基础,提供了创建、控制和管理线程的方法。本文将深入探讨C#...
这些实例不仅覆盖了多线程的基础应用,还涉及到高级的并发控制和同步技术,对于理解和掌握C#.NET中的多线程编程有极大的帮助。通过分析和运行这些实例,开发者可以深入理解多线程在实际项目中的运用,提升解决问题的...
在C#编程语言中,多线程是一种强大的技术,它允许程序同时执行多个任务,从而提高了应用程序的效率和响应性。多线程是现代计算环境中不可或缺的一部分,尤其是在处理大量数据、进行复杂计算或者需要实现并发操作的...
为了解决这个问题,我们可以使用C#的`System.Threading`命名空间中的同步原语,如`Mutex`、`Semaphore`或`Monitor`。这里我们将使用`lock`关键字,这是一种简单且高效的同步机制,它会获取一个对象的锁并执行代码块...
本文将深入探讨在多线程环境中使用List时遇到的非线程安全问题,并提供相应的解决方案和最佳实践。 List是.NET框架中常用的一个动态数组,它提供了方便的增删改查操作。然而,List并未设计为线程安全的容器,这意味...