c#线程-线程同步
线程同步
上一篇介绍了如何开启线程,线程间相互传递参数,及线程中本地变量和全局共享变量区别。
本篇主要说明线程同步。
如果有多个线程同时访问共享数据的时候,就必须要用线程同步,防止共享数据被破坏。如果多个线程不会同时访问共享数据,可以不用线程同步。
线程同步也会有一些问题存在:
- 性能损耗。获取,释放锁,线程上下文建切换都是耗性能的。
- 同步会使线程排队等待执行。
线程同步的几种方法:
阻塞
当线程调用Sleep,Join,EndInvoke,线程就处于阻塞状态(Sleep使调用线程阻塞,Join、EndInvoke使另外一个线程阻塞),会立即从cpu退出。(阻塞状态的线程不消耗cpu)
当线程在阻塞和非阻塞状态间切换时会消耗几毫秒时间。
//Join
static void Main()
{
Thread t = new Thread (Go);
Console.WriteLine ("Main方法已经运行....");
t.Start();
t.Join();//阻塞Main方法
Console.WriteLine ("Main方法解除阻塞,继续运行...");
}
static void Go()
{
Console.WriteLine ("在t线程上运行Go方法...");
}
//Sleep
static void Main()
{
Console.WriteLine ("Main方法已经运行....");
Thread.CurrentThread.Sleep(3000);//阻塞当前线程
Console.WriteLine ("Main方法解除阻塞,继续运行...");
}
//Task
static void Main()
{
Task Task1=Task.Run(() => {
Console.WriteLine("task方法执行...");
Thread.Sleep(1000);
});
Console.WriteLine(Task1.IsCompleted);
Task1.Wait();//阻塞主线程 ,等该Task1完成
Console.WriteLine(Task1.IsCompleted);
}
加锁(lock)
加锁使多个线程同一时间只有一个线程可以调用该方法,其他线程被阻塞。
同步对象的选择:
- 使用引用类型,值类型加锁时会装箱,产生一个新的对象。
- 使用private修饰,使用public时易产生死锁。(使用lock(this),lock(typeof(实例))时,该类也应该是private)。
- string不能作为锁对象。
- 不能在lock中使用
await
关键字
锁是否必须是静态类型?
如果被锁定的方法是静态的,那么这个锁必须是静态类型。这样就是在全局锁定了该方法,不管该类有多少个实例,都要排队执行。
如果被锁定的方法不是静态的,那么不能使用静态类型的锁,因为被锁定的方法是属于实例的,只要该实例调用锁定方法不产生损坏就可以,不同实例间是不需要锁的。这个锁只锁该实例的方法,而不是锁所有实例的方法.*
class ThreadSafe
{
private static object _locker = new object();
void Go()
{
lock (_locker)
{
......//共享数据的操作 (Static Method),使用静态锁确保所有实例排队执行
}
}
private object _locker2=new object();
void GoTo()
{
lock(_locker2)
//共享数据的操作,非静态方法,是用非静态锁,确保同一个实例的方法调用者排队执行
}
}
同步对象可以兼作它lock的对象
如:
class ThreadSafe
{
private List <string> _list = new List <string>();
void Test()
{
lock (_list)
{
_list.Add ("Item 1");
}
}
}
Monitors
lock
其实是Monitors
的简洁写法。
lock (x)
{
DoSomething();
}
两者其实是一样的。
System.Object obj = (System.Object)x;
System.Threading.Monitor.Enter(obj);
try
{
DoSomething();
}
finally
{
System.Threading.Monitor.Exit(obj);
}
互斥锁(Mutex)
互斥锁是一个互斥的同步对象,同一时间有且仅有一个线程可以获取它。可以实现进程级别上线程的同步。
class Program
{
//实例化一个互斥锁
public static Mutex mutex = new Mutex();
static void Main(string[] args)
{
for (int i = 0; i < 3; i++)
{
//在不同的线程中调用受互斥锁保护的方法
Thread test = new Thread(MutexMethod);
test.Start();
}
Console.Read();
}
public static void MutexMethod()
{
Console.WriteLine("{0} 请求获取互斥锁", Thread.CurrentThread.Name);
mut.WaitOne();
Console.WriteLine("{0} 已获取到互斥锁", Thread.CurrentThread.Name);
Thread.Sleep(1000);
Console.WriteLine("{0} 准备释放互斥锁", Thread.CurrentThread.Name);
// 释放互斥锁
mut.ReleaseMutex();
Console.WriteLine("{0} 已经释放互斥锁", Thread.CurrentThread.Name);
}
}
互斥锁可以在不同的进程间实现线程同步
使用互斥锁实现一个一次只能启动一个应用程序的功能。
public static class SingleInstance
{
private static Mutex m;
public static bool IsSingleInstance()
{
//是否需要创建一个应用
Boolean isCreateNew = false;
try
{
m = new Mutex(initiallyOwned: true, name: "SingleInstanceMutex", createdNew: out isCreateNew);
}
catch (Exception ex)
{
}
return isCreateNew;
}
}
互斥锁的带有三个参数的构造函数
initiallyOwned: 如果initiallyOwned为true,互斥锁的初始状态就是被所实例化的线程所获取,否则实例化的线程处于未获取状态。
name:该互斥锁的名字,在操作系统中只有一个命名为name的互斥锁mutex,如果一个线程得到这个name的互斥锁,其他线程就无法得到这个互斥锁了,必须等待那个线程对这个线程释放。
createNew:如果指定名称的互斥体已经存在就返回false,否则返回true。
信号和句柄
lock
和mutex
可以实现线程同步,确保一次只有一个线程执行。但是线程间的通信就不能实现。如果线程需要相互通信的话就要使用AutoResetEvent
,ManualResetEvent
,通过信号来相互通信。它们都有两个状态,终止状态和非终止状态。只有处于非终止状态时,线程才可以阻塞。
AutoResetEvent
:
AutoResetEvent
构造函数可以传入一个bool类型的参数,false
表示将AutoResetEvent
对象的初始状态设置为非终止。如果为true
标识终止状态,那么WaitOne
方法就不会再阻塞线程了。但是因为该类会自动的将终止状态修改为非终止,所以,之后再调用WaitOne
方法就会被阻塞。
WaitOne
方法如果AutoResetEvent
对象状态非终止,则阻塞调用该方法的线程。可以指定时间,若没有获取到信号,返回false
set
方法释放被阻塞的线程。但是一次只可以释放一个被阻塞的线程。
class ThreadSafe
{
static AutoResetEvent autoEvent;
static void Main()
{
//使AutoResetEvent处于非终止状态
autoEvent = new AutoResetEvent(false);
Console.WriteLine("主线程运行...");
Thread t = new Thread(DoWork);
t.Start();
Console.WriteLine("主线程sleep 1秒...");
Thread.Sleep(1000);
Console.WriteLine("主线程释放信号...");
autoEvent.Set();
}
static void DoWork()
{
Console.WriteLine(" t线程运行DoWork方法,阻塞自己等待main线程信号...");
autoEvent.WaitOne();
Console.WriteLine(" t线程DoWork方法获取到main线程信号,继续执行...");
}
}
//输出
//主线程运行...
//主线程sleep 1秒...
// t线程运行DoWork方法,阻塞自己等待main线程信号...
//主线程释放信号...
// t线程DoWork方法获取到main线程信号,继续执行...
ManualResetEvent
ManualResetEvent
和AutoResetEvent
用法类似。
AutoResetEvent
在调用了Set
方法后,会自动的将信号由释放(终止)改为阻塞(非终止),一次只有一个线程会得到释放信号。而ManualResetEvent
在调用Set
方法后不会自动的将信号由释放(终止)改为阻塞(非终止),而是一直保持释放信号,使得一次有多个被阻塞线程运行,只能手动的调用Reset
方法,将信号由释放(终止)改为阻塞(非终止),之后的再调用Wait.One方法的线程才会被再次阻塞。
public class ThreadSafe
{
//创建一个处于非终止状态的ManualResetEvent
private static ManualResetEvent mre = new ManualResetEvent(false);
static void Main()
{
for(int i = 0; i <= 2; i++)
{
Thread t = new Thread(ThreadProc);
t.Name = "Thread_" + i;
t.Start();
}
Thread.Sleep(500);
Console.WriteLine("\n新线程的方法已经启动,且被阻塞,调用Set释放阻塞线程");
mre.Set();
Thread.Sleep(500);
Console.WriteLine("\n当ManualResetEvent处于终止状态时,调用由Wait.One方法的多线程,不会被阻塞。");
for(int i = 3; i <= 4; i++)
{
Thread t = new Thread(ThreadProc);
t.Name = "Thread_" + i;
t.Start();
}
Thread.Sleep(500);
Console.WriteLine("\n调用Reset方法,ManualResetEvent处于非阻塞状态,此时调用Wait.One方法的线程再次被阻塞");
mre.Reset();
Thread t5 = new Thread(ThreadProc);
t5.Name = "Thread_5";
t5.Start();
Thread.Sleep(500);
Console.WriteLine("\n调用Set方法,释放阻塞线程");
mre.Set();
}
private static void ThreadProc()
{
string name = Thread.CurrentThread.Name;
Console.WriteLine(name + " 运行并调用WaitOne()");
mre.WaitOne();
Console.WriteLine(name + " 结束");
}
}
//Thread_2 运行并调用WaitOne()
//Thread_1 运行并调用WaitOne()
//Thread_0 运行并调用WaitOne()
//新线程的方法已经启动,且被阻塞,调用Set释放阻塞线程
//Thread_2 结束
//Thread_1 结束
//Thread_0 结束
//当ManualResetEvent处于终止状态时,调用由Wait.One方法的多线程,不会被阻塞。
//Thread_3 运行并调用WaitOne()
//Thread_4 运行并调用WaitOne()
//Thread_4 结束
//Thread_3 结束
///调用Reset方法,ManualResetEvent处于非阻塞状态,此时调用Wait.One方法的线程再次被阻塞
//Thread_5 运行并调用WaitOne()
//调用Set方法,释放阻塞线程
//Thread_5 结束
Interlocked
如果一个变量被多个线程修改,读取。可以用Interlocked
。
计算机上不能保证对一个数据的增删是原子性的,因为对数据的操作也是分步骤的:
- 将实例变量中的值加载到寄存器中。
- 增加或减少该值。
- 在实例变量中存储该值。
Interlocked
为多线程共享的变量提供原子操作。
Interlocked
提供了需要原子操作的方法:
public static int Add (ref int location1, int value); 两个参数相加,且把结果和赋值该第一个参数。
public static int Increment (ref int location); 自增。
public static int CompareExchange (ref int location1, int value, int comparand);
location1 和comparand比较,被value替换. value 如果第一个参数和第三个参数相等,那么就把value赋值给第一个参数。 comparand 和第一个参数对比。
ReaderWriterLock
如果要确保一个资源或数据在被访问之前是最新的。那么就可以使用ReaderWriterLock
.该锁确保在对资源获取赋值或更新时,只有它自己可以访问这些资源,其他线程都不可以访问。即排它锁。但用改锁读取这些数据时,不能实现排它锁。
lock
允许同一时间只有一个线程执行。而ReaderWriterLock
允许同一时间有多个线程可以执行读操作,或者只有一个有排它锁的线程执行写操作。
class Program
{
// 创建一个对象
public static ReaderWriterLock readerwritelock = new ReaderWriterLock();
static void Main(string[] args)
{
//创建一个线程读取数据
Thread t1 = new Thread(Write);
// t1.Start(1);
Thread t2 = new Thread(Write);
//t2.Start(2);
// 创建10个线程读取数据
for (int i = 3; i < 6; i++)
{
Thread t = new Thread(Read);
// t.Start(i);
}
Console.Read();
}
// 写入方法
public static void Write(object i)
{
// 获取写入锁,20毫秒超时。
Console.WriteLine("线程:" + i + "准备写...");
readerwritelock.AcquireWriterLock(Timeout.Infinite);
Console.WriteLine("线程:" + i + " 写操作" + DateTime.Now);
// 释放写入锁
Console.WriteLine("线程:" + i + "写结束...");
Thread.Sleep(1000);
readerwritelock.ReleaseWriterLock();
}
// 读取方法
public static void Read(object i)
{
Console.WriteLine("线程:" + i + "准备读...");
// 获取读取锁,20毫秒超时
readerwritelock.AcquireReaderLock(Timeout.Infinite);
Console.WriteLine("线程:" + i + " 读操作" + DateTime.Now);
// 释放读取锁
Console.WriteLine("线程:" + i + "读结束...");
Thread.Sleep(1000);
readerwritelock.ReleaseReaderLock();
}
}
//分别屏蔽writer和reader方法。可以更清晰的看到 writer被阻塞了。而reader没有被阻塞。
//屏蔽reader方法
//线程:1准备写...
//线程:1 写操作2017/7/5 17:50:01
//线程:1写结束...
//线程:2准备写...
//线程:2 写操作2017/7/5 17:50:02
//线程:2写结束...
//屏蔽writer方法
//线程:3准备读...
//线程:5准备读...
//线程:4准备读...
//线程:5 读操作2017/7/5 17:50:54
//线程:5读结束...
//线程:3 读操作2017/7/5 17:50:54
//线程:3读结束...
//线程:4 读操作2017/7/5 17:50:54
//线程:4读结束...
参考:
- MSDN
- 《CLR via C#》
c#线程-线程同步的更多相关文章
- Java线程:线程的同步-同步方法
Java线程:线程的同步-同步方法 线程的同步是保证多线程安全访问竞争资源的一种手段. 线程的同步是Java多线程编程的难点,往往开发者搞不清楚什么是竞争资源.什么时候需要考虑同步,怎么同步等等问 ...
- Java线程:线程的同步与锁
一.同步问题提出 线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏. 例如:两个线程ThreadA.ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据. public ...
- java 线程数据同步
java 线程数据同步 由买票实例 //java线程实例 //线程数据同步 //卖票问题 //避免重复卖票 //线程 class xc1 implements Runnable{ //定义为静态,可以 ...
- Java多线程-线程的同步与锁
一.同步问题提出 线程的同步是为了防止多个线程访问一个数据对象时,对数据造成的破坏.例如:两个线程ThreadA.ThreadB都操作同一个对象Foo对象,并修改Foo对象上的数据. package ...
- C++ 11 线程的同步与互斥
这次写的线程的同步与互斥,不依赖于任何系统,完全使用了C++11标准的新特性来写的,就连线程函数都用了C++11标准的lambda表达式. /* * thread_test.cpp * * Copyr ...
- C#线程间同步无法关闭
用C#做了个线程间同步的小程序,但每次关闭窗口后进程仍然在,是什么原因? 解决方法: 要加一句 线程.IsBackground = true; 否则退出的只是窗体 上面的方法没看懂... MSDN上说 ...
- 线程间同步之 semaphore(信号量)
原文地址:http://www.cnblogs.com/yuqilin/archive/2011/10/16/2214429.html semaphore 可用于进程间同步也可用于同一个进程间的线程同 ...
- Linux系统编程(29)——线程间同步(续篇)
线程间的同步还有这样一种情况:线程A需要等某个条件成立才能继续往下执行,现在这个条件不成立,线程A就阻塞等待,而线程B在执行过程中使这个条件成立了,就唤醒线程A继续执行.在pthread库中通过条件变 ...
- linux线程间同步方式汇总
抽空做了下linux所有线程间同步方式的汇总(原生的),包含以下几个: 1, mutex 2, condition variable 3, reader-writer lock 4, spin loc ...
- C#之任务,线程和同步
1 概述 对于所有需要等待 的操作,例 如 ,因 为文件 . 数据库或网络访 问都需要一定 的时间,此 时就可以启 动一个新线程,同时完成其他任务,即使是处理密集型的任务,线程也是有帮助的. 2 Pa ...
随机推荐
- 伪元素after,before,css/js控制样式
CSS<style> body { font: 200%/1.45 charter; } ref::before { content: '\00A7'; letter-spacing: . ...
- Extjs5.0 学习之路【资源篇】
磨刀不误砍柴工. 先收集资源,然后再开始学习之路. Extjs5.0 文件下载 API-5.0 API离线包 http://cdn.sencha.com/downloads/docs/ext-docs ...
- GWT嵌入纯HTML页面
众所周知,gwt页面是java代码所写,不存在html页面直接作用于gwt面板中.不过gwt也倒是提供了一些可用的功能,比如frame,这个是UI中的一个,内部可以设置URL,但是经过我测试后发现,这 ...
- 蓝桥杯 算法训练 ALGO-120 学做菜
算法训练 学做菜 时间限制:1.0s 内存限制:256.0MB 问题描述 涛涛立志要做新好青年,他最近在学做菜.由于技术还很生疏,他只会用鸡蛋,西红柿,鸡丁,辣酱这四种原料来做菜,我们给这四种 ...
- java代码包装类----------Integer
总结:我的笔试挂了..基础的继承不懂不会.我不知道到底是哪里的问题. 要好好反思 package com.da.ima2; public class jrfk { // int整型不能直接转化为Int ...
- Network(lca暴力)
Network Time Limit : 2000/1000ms (Java/Other) Memory Limit : 65536/65536K (Java/Other) Total Submi ...
- JAVA方法中的参数用final来修饰的效果
很多人都说在JAVA中用final来修饰方法参数的原因是防止方法参数在调用时被篡改,其实也就是这个原因,但理解起来可能会有歧义,我们需要注意的是,在final修饰的方法参数中,如果修饰的是基本类型,那 ...
- react-router4.x 实用例子(路由过渡动画、代码分割)
react-router4.2.0实用例子 代码分割 官网上面写的代码分割是不支持create-react-app脚手架的,要使用import实现 创建一个bundle.js文件 import { C ...
- C#改变LInqToSQL的引用地址,读取config的数据库字符串
C#改变LInqToSQL的引用地址,读取config的数据库字符串修改Properties 下 Settings.Settings 下 Settings.Designer.cs 下 return ( ...
- leetcode482
这道题主要使用了C++的几个API,大小写转化,字符串替换.其余的逻辑都比较简单.而且经查资料,string类字符串拼接的速度使用+=的速度是很快的.以下代码,也是用的+=来拼接字符串. string ...