计时器在很多应用场景中广泛应用，System.Threading命名空间下，有个Timer类可以完成计时器的操作。
下面来讨论下Timer类的使用及多个CPU内核同时运行线程时如何共享高速缓存(cache)的。
主要内容：
- 计时器的使用
- CPU高速缓存的伪共享
1. 计时器的使用
1.1 计时器的创建及改变设置
计时器创建的API都类似，有以下5种：
public Timer(TimerCallback callback); public Timer(TimerCallback callback, object state, int dueTime, int period); public Timer(TimerCallback callback, object state, long dueTime, long period); public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period); public Timer(TimerCallback callback, object state, uint dueTime, uint period);
其中各个参数的含义如下：
- callback：定时执行的操作
- state：传递给callback的参数
- dueTime：首次调用callback时，需要等待多少毫秒
- period：每隔多少毫秒执行一次callback
下面例子演示如何创建一个计时器，并且在运行10秒后如何改变计时器的dueTime和period
using System;
using System.Threading;
public class CLRviaCSharp_20
{
static void Main(string[] args)
{
// 定义一个定时器，每2秒执行一次
Timer t = new Timer(PrintTime, "Timer Test", 0, 2000);
// 主线程等待10秒(让计时器先执行6次)
Thread.Sleep(10000);
// 改变计时器的设置，停3秒后，每2秒执行一次
t.Change(3000, 1000);
Console.ReadKey(true);
}
private static void PrintTime(object state)
{
Thread.Sleep(3000);
Console.WriteLine("{0}: Now is {1}", state, DateTime.Now);
}
}
运行上面的例子，我们发现有以下现象：
- 刚开始每隔2秒打印一次当前时间
- 10秒后，每隔1秒打印一次当前时间
- callback(即PrintTime函数)中虽然有Sleep(3000);但计时器的下一次callback并没有等待本次callback完成就开始运行了。
对于上述的第三点，是由于Timer在每个period到期时，如果上个callback没完成，会在线程池中再启动一个线程来完成本次的callback。
1.2 耗时操作（操作消耗的时间 > 计时器的时间间隔）
但是，对于某些应用场景，可能需要callback一个一个顺序执行。
如果callback的耗时较长，希望下次callback能在本次callback完成后，再过period后执行。这时，就需要我们使用Timer的Change方法实现。
using System;
using System.Threading;
public class CLRviaCSharp_20
{
static Timer t;
static void Main(string[] args)
{
// 定义一个计时器，
// period参数设置为Timeout.Infinite的意思是计时器执行一次就结束
t = new Timer(PrintTime, "Timer Test", 0, Timeout.Infinite);
Console.ReadKey(true);
}
private static void PrintTime(object state)
{
Thread.Sleep(3000);
Console.WriteLine("{0}: Now is {1}", state, DateTime.Now);
// 因为计时器执行一次就结束，所以在callback(即PrintTime)执行完后再启动一个计时器
// 此计时器仍然设置period参数设置为Timeout.Infinite
// 并且设置dueTime参数为2000毫秒，从而保证下次callback在本次callback完成2秒后执行
// 这样不管每个callback耗用多少时间，两个callback之间的间隔时间始终是2秒
t = new Timer(PrintTime, "Timer Test", 2000, Timeout.Infinite);
}
}
这样运行结果就是每隔5秒打印一次时间了。
其中2秒表示callback之间的间隔。
另外3秒表示callback的执行时间。
2. CPU高速缓存的伪共享
为了提高CPU反复访问内存的能力，在CPU芯片上集成了高速缓存，它的访问速度非常快。
CPU从内存读取数据时，会把读取到的数据存在高速缓存中。下次直接从高速缓存中读取，从而提升性能。
CPU每次读取数据时填充的缓存大小与本机的CPU有关，我的机器是64byte。
可用CPU-Z来查看。
在多核的情况下，如何2个内核使用的数据在一个缓存线(即上面的64byte)中，那么反而会影响性能。
因为内核A如果改变了数据后，内核B需要把内核A使用的缓存线(即上面的64byte)拷入到B的缓存线中。
反之，内核A再次操作数据时，也要把内核B使用的缓存线(即上面的64byte)拷回来。
但是，如果内核A和内核B使用的数据不在一个缓存线中，那么性能就会提高，因为少了上面的不同内核之间缓存线的拷贝操作。
下面用例子来演示两种情况下的性能。
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
public class CLRviaCSharp_20
{
// 因为我的机器的缓存线为64byte，
// 所以两个int型字段应该在同一个缓存线中
private class ShareData1
{
public int field1;
public int field2;
}
// 通过设置使得两个int型字段不在一个缓存线中
[StructLayout(LayoutKind.Explicit)]
private class ShareData2
{
[FieldOffset(0)]
public int field1;
[FieldOffset(64)]
public int field2;
}
static void Main(string[] args)
{
int iterations = 100000000;
ShareData1 data1 = new ShareData1();
// 情况一：2个数据在一个缓存行中
long start = Stopwatch.GetTimestamp();
Task t1 = new Task(() => {
for (int i = 0; i < iterations; i++)
data1.field1++;
});
Task t2 = new Task(() => {
for (int i = 0; i < iterations; i++)
data1.field2++;
});
t1.Start();
t2.Start();
Task.WaitAll();
Console.WriteLine("Totle time is : {0:N0}", (Stopwatch.GetTimestamp() - start));
// 情况二：2个数据不在一个缓存行中
ShareData2 data2 = new ShareData2();
start = Stopwatch.GetTimestamp();
Task t3 = new Task(() =>
{
for (int i = 0; i < iterations; i++)
data2.field1++;
});
Task t4 = new Task(() =>
{
for (int i = 0; i < iterations; i++)
data2.field2++;
});
t3.Start();
t4.Start();
Task.WaitAll();
Console.WriteLine("Totle time is : {0:N0}", (Stopwatch.GetTimestamp() - start));
Console.ReadKey(true);
}
}
在我的双核机器上，明显第二种情况性能要优于第一种情况。