最近公司的一个项目中用到大量的泛型,一直想找找关于泛型的使用对性能造成的影响方面的文章,今天看到一个朋友测试了一个,暂时先放这
规范对于泛型举了一个如下的例子:
public
class
Stack
{
object[] items;
int count;
public void Push(object item) {}
public object Pop() {}
}
.
.
.
Stack stack = new Stack();
stack.Push( 3 );
int i = ( int )stack.Pop();
{
object[] items;
int count;
public void Push(object item) {}
public object Pop() {}
}
.
.
.
Stack stack = new Stack();
stack.Push( 3 );
int i = ( int )stack.Pop();
在这个普通的例子中,会执行box和unbox操作,并且在运行时会动态的检查类型,这样会影响性能(在一些blog上,有些兄弟用了"严重"两个字来形容).于是规范下面便接着举了一个使用泛型的例子(略).泛型不用执行box和unbox操作,并且不用在运行时动态检查,大大提高了性能.读到这里,我做了下面一个小实验,然后又修改实验代码,得到两个疑问.类似规范,我做了两个栈类.
一个普通栈:
class
Stack
{
object[] items = new object[1000000];
public int count = 0;
public void Push(object item)
{
items[count++] = item;
}
public object Pop()
{
return items[--count];
}
}
{
object[] items = new object[1000000];
public int count = 0;
public void Push(object item)
{
items[count++] = item;
}
public object Pop()
{
return items[--count];
}
}
一个泛型栈:
class
GStack
<
T
>
{
T[] items = new T[1000000];
public int count = 0;
public void Push(T item)
{
items[count++] = item;
}
public T Pop()
{
return items[--count];
}
}
{
T[] items = new T[1000000];
public int count = 0;
public void Push(T item)
{
items[count++] = item;
}
public T Pop()
{
return items[--count];
}
}
程序主函数如下:
static
void
Main(
string
[] args)
{
DateTime normalBeginTime = DateTime.Now;
Stack normalStack = new Stack();//建立一个普通栈
for (int i = 1; i <= 1000000; i++)
{
normalStack.Push(i); //将int植入栈,执行box操作
}
int normalCount = normalStack.count;
while (normalCount > 0)
{
int item = (int)normalStack.Pop(); //将int出栈,执行unbox操作
//Console.WriteLine(item.ToString());
normalCount--;
}
DateTime normalEndTime = DateTime.Now;
TimeSpan normalCostTime = normalEndTime - normalBeginTime;
DateTime genericBeginTime = DateTime.Now;
GStack<int> genericStack = new GStack<int>(); //建立一个泛型栈
for (int i = 1; i <= 1000000; i++)
{
genericStack.Push(i);
}
int genericCount = genericStack.count;
while (genericCount > 0)
{
int item = genericStack.Pop();
//Console.WriteLine(item.ToString());
genericCount--;
}
DateTime genericEndTime = DateTime.Now;
TimeSpan genericCostTime = genericEndTime - genericBeginTime;
Console.WriteLine("Normal Type:" + normalCostTime.TotalMilliseconds);
Console.WriteLine("Generic Type:" + genericCostTime.TotalMilliseconds);
Console.Read();
}
{
DateTime normalBeginTime = DateTime.Now;
Stack normalStack = new Stack();//建立一个普通栈
for (int i = 1; i <= 1000000; i++)
{
normalStack.Push(i); //将int植入栈,执行box操作
}
int normalCount = normalStack.count;
while (normalCount > 0)
{
int item = (int)normalStack.Pop(); //将int出栈,执行unbox操作
//Console.WriteLine(item.ToString());
normalCount--;
}
DateTime normalEndTime = DateTime.Now;
TimeSpan normalCostTime = normalEndTime - normalBeginTime;
DateTime genericBeginTime = DateTime.Now;
GStack<int> genericStack = new GStack<int>(); //建立一个泛型栈
for (int i = 1; i <= 1000000; i++)
{
genericStack.Push(i);
}
int genericCount = genericStack.count;
while (genericCount > 0)
{
int item = genericStack.Pop();
//Console.WriteLine(item.ToString());
genericCount--;
}
DateTime genericEndTime = DateTime.Now;
TimeSpan genericCostTime = genericEndTime - genericBeginTime;
Console.WriteLine("Normal Type:" + normalCostTime.TotalMilliseconds);
Console.WriteLine("Generic Type:" + genericCostTime.TotalMilliseconds);
Console.Read();
}
正如意料中那样,在这个例子中,执行完100W次出/入栈操作后,由于普通栈频繁的box/unbox操作,速度比使用泛型栈慢大概3-4倍.接着,我又做了下面试验,得出了两个疑问:
1.我将两个栈的大小改为100,每个出栈操作后紧跟一个打印,将出栈的值打印出来.这时候普通栈出/入栈100次的速度比泛型栈快了9-10倍,难道这两个栈出栈的int值有什么区别吗?(一个执行了unbox,一个没有?)
2.我将两个的大小改为1000W,但出/入栈次数都改为100次,这时,普通栈花费的时间几乎为0,而泛型栈花费了46毫秒左右。难道实例化泛型栈所花费的时间更多?为什么?