使用Windbg调试Net程序

如何在服务器上抓包:

利用一个VBS文件,输入内容:

Set objShell = CreateObject(“Wscript.Shell”)
Dim InputPid
InputPid = InputBox(“请输入Pid”)
objCommand1 = “””C:\Program Files\Debugging Tools for Windows (x64)\adplus.vbs””” & ” -hang -o d:\dump -quiet -p ” & InputPid
objShell.Run(objCommand1)

在服务器上执行。

也可以到命令行下面,然后切换到windbg目录,执行adplus -hang -p PID sosbasics.exe -o d:\dump

,在Windbg按Ctrl+D,打开抓包的那个文件:

就可以输入命令查看信息了,

以后是一些常用的命令:

加载sos:.load clr20\sos.dll

.loadby sos mscorwks 导入 这意思是自己去微软框架中找SOS,也可以.load SOS.dll ,但SOS要拷到Windbg下面。
!threads 列出所有线程
!threadpool 看线程池状态

!runaway 列出 所有线程时间(CPU100%时用的多)

!syncblk 看几个线程是锁的状态,锁不占资源,但解锁占用,多线程会抢资源,有Hang所有线程就会挂起,当队列15000个,服务器就

Server Too Busy了。
.time 线程执行时间

~  查看所有线程
~54s  查看54号线程
kb  看线程,在被抓的那一刻,在调用什么。可看非托管
!clrstack 看线程的堆栈信息
~*e !clrstack  看所有线程的堆栈信息

~5e !clrstack  看5号线程的堆栈信息

!dd, !dso(Dump Stack Objects的缩写),这个命令可以把当前栈上所有的变量都搞出来。

!dumpheap -stat 当前托管堆分配情况(内存泄露)

!dumpheap -mt  查看一个对象的分配情况 -mt元数据的地址

!do 地址  查看一个对象的详细

!da 地址  查看一个数组的详细

!eeheap -gc。这个命令表明,我们程序占用托管堆的大小:

LM:查看加载的所有模块的起始地址

!savemodule: 保存成DLL (先用LM找起始地址)

!eeversion 查看CLR与SOS版本

!pe 打印当前线程上的托管异常信息

【内存泄漏】
1、!dumpheap -stat看看哪些对象个数最多,占内存最大,
2、找到某个格式比较多的对象,可以看它的方法表,然后用!dumpheap -mt 66398fa4去随机找几个对象的地址
3、用!do 1e5a22bc命令去查看几个对象的状态,属性的值等,看看正常不正常
4、用!gcroot -nostacks 1e5a22bc去查看几个对象的根正常不正常,如果有些对象的根不是自己预先设计的那样,很可能被自己没想到的对象强引用了,所以GC无法回收它,就泄漏了。
【CPU百分百】
主要用几个计数器和!runaway命令,具体见以下链接
http://www.cnblogs.com/onlytianc … 7/06/03/769307.html
【线程池耗尽】
!threadpool 能看到完成端口,线程池工作线程和timer回调各占线程池的情况。
【其它】
1、!eestack -short -ee查看所有重要(获取锁的,托管的,停止并允许回收的)线程的dumpstack,差不多相当于~*e!dumpstack
2、.time 可以看到进程跑了多少时间
3、!dso 查看当前线程里有哪些对象,分析内存泄漏问题也许会用到

0:000> .load wow64exts

0:000> !sw

关于更多的Windbg学习, 大家可以去看:

微软测试部总管Tess的文章:http://blogs.msdn.com/b/tess/

国内的有鞠强的文章 :http://www.cnblogs.com/juqiang/

详解lock,monitor,同步事件和等待句柄以及mutex

c#线程同步

最近由于在准备Collection对象培训的PPT,因为涉及到SyncRoot的属性的讲解,所以对怎样在多线程应用程序中同步资源访问做了个总结:
对于引用类型和非线程安全的资源的同步处理,有四种相关处理:lock关键字,监视器(Monitor),同步事件和等待句柄,mutex类。
Lock关键字
本人愚钝,在以前编程中遇到lock的问题总是使用lock(this)一锁了之,出问题后翻看MSDN突然发现下面几行字:通常,应避免锁定 public 类型,否则实例将超出代码的控制范围。常见的结构 lock (this)、lock (typeof (MyType)) 和 lock (“myLock”) 违反此准则:如果实例可以被公共访问,将出现 lock (this) 问题。如果 MyType 可以被公共访问,将出现 lock (typeof (MyType)) 问题。由于进程中使用同一字符串的任何其他代码将共享同一个锁,所以出现 lock(“myLock”) 问题。来看看lock(this)的问题:如果有一个类Class1,该类有一个方法用lock(this)来实现互斥:
public void Method2()
{
lock (this)
{
System.Windows.Forms.MessageBox.Show(“Method2 End”);
}
}
如果在同一个Class1的实例中,该Method2能够互斥的执行。但是如果是2个Class1的实例分别来执行Method2,是没有互斥效果的。因为这里的lock,只是对当前的实例对象进行了加锁。
Lock(typeof(MyType))锁定住的对象范围更为广泛,由于一个类的所有实例都只有一个类型对象(该对象是typeof的返回结果),锁定它,就锁定了该对象的所有实例,微软现在建议(原文请参考:http://www.microsoft.com/china/MSDN/library/enterprisedevelopment/softwaredev/SDaskgui06032003.mspx?mfr=true)不要使用lock(typeof(MyType)),因为锁定类型对象是个很缓慢的过程,并且类中的其他线程、甚至在同一个应用程序域中运行的其他程序都可以访问该类型对象,因此,它们就有可能代替您锁定类型对象,完全阻止您的执行,从而导致你自己的代码的挂起。
锁住一个字符串更为神奇,只要字符串内容相同,就能引起程序挂起。原因是在.NET中,字符串会被暂时存放,如果两个变量的字符串内容相同的话,.NET会把暂存的字符串对象分配给该变量。所以如果有两个地方都在使用lock(“my lock”)的话,它们实际锁住的是同一个对象。到此,微软给出了个lock的建议用法:锁定一个私有的static 成员变量。
.NET在一些集合类中(比如ArrayList,HashTable,Queue,Stack)已经提供了一个供lock使用的对象SyncRoot,用Reflector工具查看了SyncRoot属性的代码,在Array中,该属性只有一句话:return this,这样和lock array的当前实例是一样的。ArrayList中的SyncRoot有所不同 get
{
if (this._syncRoot == null)
{
Interlocked.CompareExchange(ref this._syncRoot, new object(), null);
}
return this._syncRoot;
其中Interlocked类是专门为多个线程共享的变量提供原子操作(如果你想锁定的对象是基本数据类型,那么请使用这个类),CompareExchange方法将当前syncRoot和null做比较,如果相等,就替换成new object(),这样做是为了保证多个线程在使用syncRoot时是线程安全的。集合类中还有一个方法是和同步相关的:Synchronized,该方法返回一个对应的集合类的wrapper类,该类是线程安全的,因为他的大部分方法都用lock来进行了同步处理,比如Add方法:public override void Add(object key, object value)
{
lock (this._table.SyncRoot)
{
this._table.Add(key, value);
}
}
这里要特别注意的是MSDN提到:从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。即使一个集合已进行同步,其他线程仍可以修改该集合,这将导致枚举数引发异常。若要在枚举过程中保证线程安全,可以在整个枚举过程中锁定集合:Queue myCollection = new Queue();
lock(myCollection.SyncRoot) {
foreach (Object item in myCollection) {
// Insert your code here.
}
}
Monitor类
该类功效和lock类似:System.Object obj = (System.Object)x;
System.Threading.Monitor.Enter(obj);
try
{
DoSomething();
}
finally
{
System.Threading.Monitor.Exit(obj);
}
lock关键字比Monitor简洁,其实lock就是对Monitor的Enter和Exit的一个封装。另外Monitor还有几个常用的方法:TryEnter能够有效的决绝长期死等的问题,如果在一个并发经常发生,而且持续时间长的环境中使用TryEnter,可以有效防止死锁或者长时间的等待。比如我们可以设置一个等待时间bool gotLock = Monitor.TryEnter(myobject,1000),让当前线程在等待1000秒后根据返回的bool值来决定是否继续下面的操作。Pulse以及PulseAll还有Wait方法是成对使用的,它们能让你更精确的控制线程之间的并发,MSDN关于这3个方法的解释很含糊,有必要用一个具体的例子来说明一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System.Threading;
public class Program {
   static object ball = new object();
   public static void Main() {
      Thread threadPing = new Thread( ThreadPingProc );
      Thread threadPong = new Thread( ThreadPongProc );
      threadPing.Start(); threadPong.Start();
      }
   static void ThreadPongProc() {
      System.Console.WriteLine("ThreadPong: Hello!");
      lock ( ball )
         for (int i = 0; i < 5; i++){
            System.Console.WriteLine("ThreadPong: Pong ");
            Monitor.Pulse( ball );
            Monitor.Wait( ball );
         }
      System.Console.WriteLine("ThreadPong: Bye!");
   }
   static void ThreadPingProc() {
      System.Console.WriteLine("ThreadPing: Hello!");
      lock ( ball )
         for(int i=0; i< 5; i++){
            System.Console.WriteLine("ThreadPing: Ping ");
            Monitor.Pulse( ball );
            Monitor.Wait( ball );
         }
      System.Console.WriteLine("ThreadPing: Bye!");
   }
}

执行结果如下(有可能是ThreadPong先执行):ThreadPing: Hello!
ThreadPing: Ping
ThreadPong: Hello!
ThreadPong: Pong
ThreadPing: Ping
ThreadPong: Pong
ThreadPing: Ping
ThreadPong: Pong
ThreadPing: Ping
ThreadPong: Pong
ThreadPing: Ping
ThreadPong: Pong
ThreadPing: Bye!
当threadPing进程进入ThreadPingProc锁定ball并调用Monitor.Pulse( ball );后,它通知threadPong从阻塞队列进入准备队列,当threadPing调用Monitor.Wait( ball )阻塞自己后,它放弃了了对ball的锁定,所以threadPong得以执行。PulseAll与Pulse方法类似,不过它是向所有在阻塞队列中的进程发送通知信号,如果只有一个线程被阻塞,那么请使用Pulse方法。
同步事件和等待句柄
同步事件和等待句柄用于解决更复杂的同步情况,比如一个一个大的计算步骤包含3个步骤result = first term + second term + third term,如果现在想写个多线程程序,同时计算first term,second term 和third term,等所有3个步骤计算好后再把它们汇总起来,我们就需要使用到同步事件和等待句柄,同步事件分有两个,分别为AutoResetEvent和ManualResetEvent,这两个类可以用来代表某个线程的运行状态:终止和非终止,等待句柄用来判断ResetEvent的状态,如果是非终止状态就一直等待,否则放行,让等待句柄下面的代码继续运行。下面的代码示例阐释了如何使用等待句柄来发送复杂数字计算的不同阶段的完成信号。此计算的格式为:result = first term + second term + third termusing System;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
using System.Threading;
class CalculateTest
{
    static void Main()
    {
        Calculate calc = new Calculate();
        Console.WriteLine("Result = {0}.",
            calc.Result(234).ToString());
        Console.WriteLine("Result = {0}.",
            calc.Result(55).ToString());
    }
}
class Calculate
{
    double baseNumber, firstTerm, secondTerm, thirdTerm;
    AutoResetEvent[] autoEvents;
    ManualResetEvent manualEvent;
    // Generate random numbers to simulate the actual calculations.
    Random randomGenerator;
    public Calculate()
    {
        autoEvents = new AutoResetEvent[]
        {
            new AutoResetEvent(false),
            new AutoResetEvent(false),
            new AutoResetEvent(false)
        };
        manualEvent = new ManualResetEvent(false);
    }
    void CalculateBase(object stateInfo)
    {
        baseNumber = randomGenerator.NextDouble();
        // Signal that baseNumber is ready.
        manualEvent.Set();
    }
    // The following CalculateX methods all perform the same
    // series of steps as commented in CalculateFirstTerm.
    void CalculateFirstTerm(object stateInfo)
    {
        // Perform a precalculation.
        double preCalc = randomGenerator.NextDouble();
        // Wait for baseNumber to be calculated.
        manualEvent.WaitOne();
        // Calculate the first term from preCalc and baseNumber.
        firstTerm = preCalc * baseNumber *
            randomGenerator.NextDouble();
        // Signal that the calculation is finished.
        autoEvents[0].Set();
    }
    void CalculateSecondTerm(object stateInfo)
    {
        double preCalc = randomGenerator.NextDouble();
        manualEvent.WaitOne();
        secondTerm = preCalc * baseNumber *
            randomGenerator.NextDouble();
        autoEvents[1].Set();
    }
    void CalculateThirdTerm(object stateInfo)
    {
        double preCalc = randomGenerator.NextDouble();
        manualEvent.WaitOne();
        thirdTerm = preCalc * baseNumber *
            randomGenerator.NextDouble();
        autoEvents[2].Set();
    }
    public double Result(int seed)
    {
        randomGenerator = new Random(seed);
        // Simultaneously calculate the terms.
        ThreadPool.QueueUserWorkItem(
            new WaitCallback(CalculateBase));
        ThreadPool.QueueUserWorkItem(
            new WaitCallback(CalculateFirstTerm));
        ThreadPool.QueueUserWorkItem(
            new WaitCallback(CalculateSecondTerm));
        ThreadPool.QueueUserWorkItem(
            new WaitCallback(CalculateThirdTerm));
        // Wait for all of the terms to be calculated.
        WaitHandle.WaitAll(autoEvents);
        // Reset the wait handle for the next calculation.
        manualEvent.Reset();
        return firstTerm + secondTerm + thirdTerm;
    }
}

该示例一共有4个ResetEvent,一个ManualEvent,三个AutoResetEvent,分别反映4个线程的运行状态。ManualEvent和AutoResetEvent有一点不同:AutoResetEvent是在当前线程调用set方法激活某线程之后,AutoResetEvent状态自动重置,而ManualEvent则需要手动调用Reset方法来重置状态。接着来看看上面那段代码的执行顺序,Main方法首先调用的是Result 方法,Result方法开启4个线程分别去执行,主线程阻塞在WaitHandle.WaitAll(autoEvents)处,等待3个计算步骤的完成。4个ResetEvent初始化状态都是非终止(构造实例时传入了false),CalculateBase首先执行完毕,其他3个线程阻塞在manualEvent.WaitOne()处,等待CalculateBase执行完成。CalculateBase生成baseNumber后,把代表自己的ManualEvent状态设置为终止状态。其他几个线程从manualEvent.WaitOne()处恢复执行,在执行完自己的代码后把自己对应的AutoResetEvent状态置为终止。当3个计算步骤执行完后,主线程从阻塞中恢复,把三个计算结果累加后返回。还要多补充一点的是WaitHandle的WaitOne,WaitAll,WaitAny方法,如果等待多个进程就用WaitAll,如本例中的:WaitHandle.WaitAll(autoEvents),WaitAny是等待的线程中有一个结束则停止等待。
Mutex 对象
Mutex与Monitor类似,这里不再累赘,需要注意的是Mutex分两种:一种是本地Mutex一种是系统级Mutex,系统级Mutex可以用来进行跨进程间的线程的同步。尽管 mutex 可以用于进程内的线程同步,但是使用 Monitor 通常更为可取,因为监视器是专门为 .NET Framework 而设计的,因而它可以更好地利用资源。相比之下,Mutex 类是 Win32 构造的包装。尽管 mutex 比监视器更为强大,但是相对于 Monitor 类,它所需要的互操作转换更消耗计算资源。
注:文中代码示例来源于MSDN和CodeProject

C#字符串格式化

C# 字符串格式化

1、格式化货币(跟系统的环境有关,中文系统默认格式化人民币,英文系统格式化美元)

string.Format(“{0:C}”,0.2) 结果为:¥0.20 (英文操作系统结果:$0.20)

默认格式化小数点后面保留两位小数,如果需要保留一位或者更多,可以指定位数
string.Format(“{0:C1}”,23.15) 结果为:¥23.2 (截取会自动四舍五入)

格式化多个Object实例
string.Format(“市场价:{0:C},优惠价{1:C}”,23.15,19.82)

2、格式化十进制的数字(格式化成固定的位数,位数不能少于未格式化前,只支持整形)

string.Format(“{0:D3}”,23) 结果为:023

string.Format(“{0:D2}”,1223) 结果为:1223,(精度说明符指示结果字符串中所需的最少数字个数。)

3、用分号隔开的数字,并指定小数点后的位数

string.Format(“{0:N}”, 14200) 结果为:14,200.00  (默认为小数点后面两位)

string.Format(“{0:N3}”, 14200.2458) 结果为:14,200.246 (自动四舍五入)

4、格式化百分比

string.Format(“{0:P}”, 0.24583) 结果为:24.58% (默认保留百分的两位小数)

string.Format(“{0:P1}”, 0.24583) 结果为:24.6% (自动四舍五入)

5、零占位符和数字占位符

string.Format(“{0:0000.00}”, 12394.039) 结果为:12394.04

string.Format(“{0:0000.00}”, 194.039) 结果为:0194.04

string.Format(“{0:###.##}”, 12394.039) 结果为:12394.04

string.Format(“{0:####.#}”, 194.039) 结果为:194

下面的这段说明比较难理解,多测试一下实际的应用就可以明白了。
零占位符:
如果格式化的值在格式字符串中出现“0”的位置有一个数字,则此数字被复制到结果字符串中。小数点前最左边的“0”的位置和小数点后最右边的“0”的位置确定总在结果字符串中出现的数字范围。
“00”说明符使得值被舍入到小数点前最近的数字,其中零位总被舍去。

数字占位符:
如果格式化的值在格式字符串中出现“#”的位置有一个数字,则此数字被复制到结果字符串中。否则,结果字符串中的此位置不存储任何值。
请注意,如果“0”不是有效数字,此说明符永不显示“0”字符,即使“0”是字符串中唯一的数字。如果“0”是所显示的数字中的有效数字,则显示“0”字符。
“##”格式字符串使得值被舍入到小数点前最近的数字,其中零总被舍去。

PS:空格占位符

string.Format(“{0,-50}”, theObj);//格式化成50个字符,原字符左对齐,不足则补空格
string.Format(“{0,50}”, theObj);//格式化成50个字符,原字符右对齐,不足则补空格

6、日期格式化

string.Format(“{0:d}”,System.DateTime.Now) 结果为:2009-3-20 (月份位置不是03)

string.Format(“{0:D}”,System.DateTime.Now) 结果为:2009年3月20日

string.Format(“{0:f}”,System.DateTime.Now) 结果为:2009年3月20日 15:37

string.Format(“{0:F}”,System.DateTime.Now) 结果为:2009年3月20日 15:37:52

string.Format(“{0:g}”,System.DateTime.Now) 结果为:2009-3-20 15:38

string.Format(“{0:G}”,System.DateTime.Now) 结果为:2009-3-20 15:39:27

string.Format(“{0:m}”,System.DateTime.Now) 结果为:3月20日

string.Format(“{0:t}”,System.DateTime.Now) 结果为:15:41

string.Format(“{0:T}”,System.DateTime.Now) 结果为:15:41:50