1,Volate.Write和Volate.Read:
bool complete = false; var t = new Thread(() => { bool toggle = false; while (!complete) { toggle = !toggle; } }); t.Start(); Thread.Sleep(1000); complete = true; t.Join(); Console.Read();
注意:该代码会无限循环,(在Release优化模式下).使用Volatile就是解决这个问题的.Volatile大致时做了这么几件事情.VolateRead(Ref Value),首先,会进行一次内存读写(而非缓存),然后,在其后面的读写操作必须在其完成后再执行.
Write操作:再执行时强制写入内存.并且那些再其之前的操作需要再Write之前发生.
也就是说,Read优先在最前面.Write往往放在最后面.(这两个函数最要用于实时读取或者写入内存中的实际值.相当于PLC中的:P功能).
2,InterLock(互锁构造).
//Increment():原子性对一个32位整数进行+1操作. //Decrement:原子性的对一个32位整数进行-1操作. //Add(),原子性的对一个32位整数进行加减操作 //Exchange(a,b)原子性的对一个32位整数进行赋值,并返回原来值 //CompareExchange(a,value,b)如果 a==b,则 a=value,并且返回a;
利用异步模式进行多服务器请求的方式:
internal sealed class MultiWebRequests { private AsyncCoordinator m_ac = new AsyncCoordinator(); private Dictionary<string, object> m_servers = new Dictionary<string, object> { {"https://www.baidu.com",null }, {"https://192.168.0.11",null } }; public MultiWebRequests(int timeout=Timeout.Infinite) { var httpClient = new HttpClient(); foreach(var server in m_servers.Keys) { m_ac.AboutToBegin(1); httpClient.GetByteArrayAsync(server).ContinueWith(task => ComputeResult(server, task)); } m_ac.AllBegun(AllDone, timeout); } private void AllDone(CoordinationStatus status) { switch (status) { case CoordinationStatus.Cancel: Console.WriteLine("operation canceled"); break; case CoordinationStatus.Timeout: Console.WriteLine("Operation timed-out"); break; case CoordinationStatus.AllDone: Console.WriteLine("operation completed;results below:"); foreach(var server in m_servers) { Console.WriteLine("{0} ", server.Key); object result = server.Value; if(result is Exception) { Console.WriteLine("failed due to {0}", result.GetType().Name); } else { Console.WriteLine("returned {0:N0} bytes.", result); } } break; } } private void ComputeResult(string server, Task<byte[]> task) { object result; if (task.Exception != null) { result = task.Exception.InnerException; } else { result = task.Result.Length; } // m_servers[server] = result; m_ac.JustEnded(); } public void Cancel() { m_ac.Cancel(); } } enum CoordinationStatus { Cancel,Timeout,AllDone} internal sealed class AsyncCoordinator { private int m_opCount = 1; private int m_statusReported = 0; private Action<CoordinationStatus> m_callback; private Timer m_timer; //协定异步计数器的大小 public void AboutToBegin(Int32 opsToAdd = 1) { Interlocked.Add(ref m_opCount, opsToAdd); } //判断是否异步计数器为0,如果为0,表明所有操作完成 public void JustEnded() { if(Interlocked.Decrement(ref m_opCount)==0) ReportStatus(CoordinationStatus.AllDone); } //当,所有异步操作执行时,执行该函数,用来启动计数器的判断模式. //当启动限时操作时,则传递委托执行当超时时,报告超时异常. public void AllBegun(Action<CoordinationStatus> callback,int timeout=Timeout.Infinite) { m_callback = callback; if (timeout != Timeout.Infinite) m_timer = new Timer(TimeExpired, null, timeout, Timeout.Infinite); JustEnded(); } //超时时,则执行报告超时. private void TimeExpired(object state) { ReportStatus(CoordinationStatus.Timeout); } //调用cancel()时,则报告Cancel(). public void Cancel() { ReportStatus(CoordinationStatus.Cancel); } //使用m_statusReorted,进行原子操作进行竞争.从而只让某个委托函数只执行一次. private void ReportStatus(CoordinationStatus status) { if (Interlocked.Exchange(ref m_statusReported, 1) == 0) m_callback(status); } }
利用Task方法,在每次请求数据结束后进行数据处理(是否异常,如果不是异常则返回结果,如果是异常则返回异常).
其次,利用协调类的m_OpCount来进行操作判断处理,判断是否所有操作处理完毕
再次,利用竞争从而只形成一次报告生成.
3,简单自旋锁:
internal struct SimpleSpinLock { private int m_ResourceInUse; public void Enter() { while (Interlocked.Exchange(ref m_ResourceInUse, 1) != 0) { //黑科技//简单自旋锁适用计算量不大的场合. } } public void Leave() { Volatile.Write(ref m_ResourceInUse, 0); } }
- 1,利用Interlock进行原子操作保证
- 2,使用Volatile保证内存写入一致.
- 3,问题,可能形成
Thread.Yeild 该方法是在 .Net 4.0 中推出的新方法，它对应的底层方法是 SwitchToThread。Yield 的中文翻译为 “放弃”，这里意思是主动放弃当前线程的时间片，并让操作系统调度其它就绪态的线程使用一个时间片。但是如果调用 Yield，只是把当前线程放入到就绪队列中，而不是阻塞队列。如果没有找到其它就绪态的线程，则当前线程继续运行。 优势：比 Thread.Sleep(0) 速度要快，可以让低于当前优先级的线程得以运行。可以通过返回值判断是否成功调度了其它线程。 劣势：只能调度同一个处理器的线程，不能调度其它处理器的线程。当没有其它就绪的线程，会一直占用 CPU 时间片，造成 CPU 100%占用率 Thread.Sleep(0) Sleep 的意思是告诉操作系统自己要休息 n 毫秒，这段时间就让给另一个就绪的线程吧。当 n=0 的时候，意思是要放弃自己剩下的时间片，但是仍然是就绪状态，其实意思和 Yield 有点类似。但是 Sleep(0) 只允许那些优先级相等或更高的线程使用当前的CPU，其它线程只能等着挨饿了。如果没有合适的线程，那当前线程会重新使用 CPU 时间片。 优势：相比 Yield，可以调度任何处理器的线程使用时间片。 劣势：只能调度优先级相等或更高的线程，意味着优先级低的线程很难获得时间片，很可能永远都调用不到。当没有符合条件的线程，会一直占用 CPU 时间片，造成 CPU 100%占用率。 Thread.Sleep(1) 该方法使用 1 作为参数，这会强制当前线程放弃剩下的时间片，并休息 1 毫秒（因为不是实时操作系统，时间无法保证精确，一般可能会滞后几毫秒或一个时间片）。但因此的好处是，所有其它就绪状态的线程都有机会竞争时间片，而不用在乎优先级。 优势：可以调度任何处理器的线程使用时间片。无论有没有符合的线程，都会放弃 CPU 时间，因此 CPU 占用率较低。 劣势：相比 Thread.Sleep(0)，因为至少会休息一定时间，所以速度要更慢。 Thread.Sleep(0) vs Sleep(1) vs Yeild
4,InterLocked Anything
public delegate Int32 Morpher<TResult, TArgument>(int startValue, TArgument argument, out TResult morphResult); //将一个委托方法变成原子操作方式: public static TResult Morph<TResult,TArgument>(ref int target,TArgument argument,Morpher<TResult,TArgument> morpher) { //方程需要的结果 TResult morphResult; //进行操作,如果数据有变化就从新操作. int currentVal = target, startVal, desiredVal; do { startVal = currentVal; desiredVal = morpher(startVal, argument, out morphResult); currentVal = Interlocked.CompareExchange(ref target, desiredVal, startVal); } while (startVal != currentVal); return morphResult; }
这是一个原子方法的扩展版本.也就是用于包装一个原子方法,保证其被更新.
这是一个实战的列子
public static void go() { int count = 0; int m_count = 0; List<Task> tasks = new List<Task>(); for(var i = 0; i < 3; i++) { var t = Task.Run(() => { for (var ii = 0; ii < 50000; ii++) { //对于count就是进行对其的原子操作.(使用Count__对其进行一次原子操作,在这里是+1) //对于m_count,其是一次伴随操作. m_count=Morph<int, int>(ref count, 1, Count__); } }); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); Console.WriteLine(count+" "+m_count); } private static int Count__(int startValue, int argument, out int morphResult) { var result = startValue + 1; morphResult = result; return result; }
5,
内核模式构造
- WaitHandle
- EventWaitHandle
- AutoResetEvent//每次运行完WaitOne自动设定成Reset.
- ManualResetEvent//需要手动设定成Reset.
- Semaphore
- Mutex
WaitHandle用于包装一个内核对象句柄.其常用方法:
WaitOne():当传递true的时候(Set())则不堵塞,否则则堵塞线程
:当返回true,表示调用了Set(),否则,当超时时,则返回False();
Set():使堵塞的WaitOne()使能为可以运行.
ReSet(): 使运行的WaitOne() 设置成堵塞.
OpenExsiting(string str)可以获取已经创建的内核句柄.
new
一个交替打印1--100的方式:
public static void go3() { var waiter1 = new AutoResetEvent(false); var waiter2 = new AutoResetEvent(false); var m_count = 1; Task.Run(() => { while (m_count <= 99) { //获取set方法或者超时,如果超时返回false,否则返回true,表示set()方法打通. var wt = waiter1.WaitOne(100); Console.WriteLine("thread1 is " + (m_count++) + "waiter is" + wt); waiter2.Set(); } }); Task.Run(() => { while (m_count <= 100) { var wt= waiter2.WaitOne(100); Console.WriteLine("thread2 is " + (m_count++)+"waiter is"+wt); waiter1.Set(); } }); }
Semaphore构造: 其实是内核维护的Int32变量.当=0的时候,在信号等待的线程阻塞,不为0的时候,解除阻塞.
构建一个Semaphore对象 New Semaphore(0,1,”name”,ref bool create_new):
创建一个独一无二的内核对象"name"如果是本线程创建,则create_new=true,否则 false;
当使用WaitOne()方法的时候,如果 Semaphore对象内部管理的信号量=0,则堵塞线程,否则 不堵塞.
每使用WaitOne()方法一次,就将信号量减1.
每使用release(count)就使信号量+count.
和AutoResetEvent不同的地方在于,多次Set(),也只会使一个线程恢复非堵塞,而Semaphore可能会造成释放多个线程.
利用AutoReset和Semaphore都可以进行自旋锁的构造.
public class SimpleLock1:IDisposable { private Semaphore m_lock = new Semaphore(1, 1); public void Enter() { m_lock.WaitOne(); } public void Leave() { m_lock.Release(); } public void Dispose() { m_lock.Close(); } }
Mutex:
互诉锁线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等待的C# Mutex对象被释放了，它就自动拥有这个对象，直到它调用Mutex.ReleaseMutex()方法释放这个对象，而在此期间，其他想要获取这个C# Mutex对象的线程都只有等待
简单点说,这个锁监视当前线程:使用WaitOne()的方法,在运行后,会使其当前线程监视值+1,使用Release()方法,会使监视值-1,当,监视值=0的时候,才可以由其他线程获取使用权.(一般避免使用这个锁,而改用自定义的递归锁(对象递归).
public static void go6() { //参数指示当前运行的线程是否获取Mutex锁,如果选择true的话,则需要释放一次,否则别的线程无法获取. var m_lock = new Mutex(false); var m_count = 1; //注意递归的用法.必须当整个线程运行完毕后,其他的线程才能够获得锁的所有权才会运行下一步. Task.Run(() => { //如果没线程在用就获取锁. while (m_count <= 100) { if (m_count % 2 == 1) { m_lock.WaitOne(); Console.WriteLine("Thread{0} is Print {1}", Thread.CurrentThread.ManagedThreadId, m_count++); m_lock.ReleaseMutex(); } } }); Task.Run(() => { while (m_count <= 100) { if (m_count % 2 == 0) { m_lock.WaitOne(); Console.WriteLine("Thread{0} is Print {1}", Thread.CurrentThread.ManagedThreadId, m_count++); m_lock.ReleaseMutex(); } } }); }
模拟递归锁
public sealed class RecursiveAutoResetEvent:IDisposable { private AutoResetEvent m_lock = new AutoResetEvent(true); private int m_owningThreadId = 0; private int m_recursionCount = 0; public void Enter() { Int32 currentThreadId = Thread.CurrentThread.ManagedThreadId; //如果当前线程是原进程 if(currentThreadId==m_owningThreadId) { m_recursionCount++; return; } //当前进程是第一次进入 m_lock.WaitOne(); //当前线程第一次拥有锁 m_owningThreadId = currentThreadId; m_recursionCount = 1; } public void Leave() { Int32 currentThreadId = Thread.CurrentThread.ManagedThreadId; if (currentThreadId != m_owningThreadId || m_recursionCount < 1) throw new InvalidOperationException("error thread"); if(--m_recursionCount==0) { m_owningThreadId = 0; m_lock.Set(); } } public void Dispose() { m_lock.Dispose(); } }