《你不常用的c#之五》:Thread与ThreadPool的内存之战

Thread与ThreadPool使用的时候在内存里对象是如何分布的呢？
今天我们就从内存堆的角度分析下两者。
先上小白鼠代码：

static void Main(string[] args)
        {
            for (int i = 0; i < 30; i++)
            {
                Thread t = new Thread(new ThreadStart(ThreadProc));
                t.Name = "Overred_" + i;
                t.Start();
            }
            Console.Read();
        }
        static void ThreadProc()
        {
            try
            {
                for (int i = 0; i < 10; i++)
                {
                     Console.WriteLine("{0}  Value:{1}",Thread.CurrentThread.Name,i);
                }
               
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
以上代码非常简单，就是循环启动30个线程去执行同一个方法ThreadProc(),然后打印出结果。
现在提出问题1：当Main里的30个线程都把ThreadProc()方法执行完毕后，这些Threads是自动消亡还是被GC回收，还是变成DeadThread？
好，拿出我们的看家工具windbg，来debug一把。
首先启动我们的程序，然后打开windbg，然后F6，Attach我们的exe
1,加载mscorwks(.net 2.0或者以上)

0:003> .loadby sos mscorwks 

2,查看该程序的线程情况

看红色加粗部分，我们总共有32个线程，而DeadThread为30个（其他2个为程序自身所有，其中一个BackgroundThread）， 先告诉你这30个死线程正式我们循环创建的线程，可以回答我提的第一个问题拉，没错，他们统统死拉，而且不会醒来，还占地方（不是永远占地方，待会我们用 GC手动让它们消亡）。

3，然后我们继续看看内存堆上它们这些坏家伙如何分布：

4，我们来具体看下这些Thread们的MethodTable

5，随便拿一个线程的Address来看看到底是谁占着我们的Thread而不让我们的GC回收掉

0:003> !GCRoot 013c3bd4
Note: Roots found on stacks may be false positives. Run "!help gcroot" for
more info.
Scan Thread 0 OSTHread 25e4
Scan Thread 2 OSTHread 24b8
DOMAIN(00514818):HANDLE(WeakSh):241298:Root:013c3bd4(System.Threading.Thread)

结果另我们很失望，他自己就是根，并没被其他任何对象所引用，什么情况下会出现此情况呢？我们先来看看对象在内存中分布的几种方式,我们只需在windbg里执行如下命令则知：

说到此，也就找到我们当初30个彪形大汉为啥赖着不走的原因拉，是在0代的第一次GC时候，他们被放进FinalizeQueue,等着第二次GC他们部分才会从内存堆上消亡。
为证明我们的观点，我们可以修改程序为 ：

static void Main(string[] args)
        {
            for (int i = 0; i < 30; i++)
            {
                Thread t = new Thread(new ThreadStart(ThreadProc));
                t.Name = "Overred_" + i;
                t.Start();
            }
            GC.Collect();
            GC.Collect();
            Console.Read();
        }

    ~Thread()
    {
        this.InternalFinalize();
    }

来个虎头蛇尾吧，当我们把小白鼠程序使用ThreadPool修改为：

希望本文能对你有所帮助，谢谢！

http://www.taheta.org/

下载地址：
http://www.microsoft.com/whdc/devtools/Debugging/installx86.mspx
Symbols path的设置
   打开windbg之后，按Ctrl+S，然后把这段(带下划线的部分）paste上：srv*c:\symcache*http://msdl.microsoft.com/download/symbols;c:\symcache;
   注意的是，那个c:\symcache是我常用的路径，你可以根据你的习惯，设置为d:\symbols等。

	39647|【满48包邮】.NET 2.0应用程序调试
	67.5元

加载sos.dll
   SOS是为了方便调试.NET程序的一个add-in，不知道哪个牛人写的……在.net framework 1.x下面，直接在windbg的命令行里面，执行.load clr10\sos.dll即可。
   在.net framework 2.0里面，我们可以到%windir%\microsoft.net\framework\v2.0.50727下面，把sos.dll，复制到 windbg安装目录下面。我一般是这样：在windbg目录下面，创建一个目录叫做clr20，然后copy sos.dll %programfiles%\Debugg~1\clr20。搞好后，加载命令是一样的：.load clr20\sos.dll即可。

使用Action、Func和Lambda表达式

在.NET在,我们经常使用委托,委托的作用不必多说，在.NET 2.0之前,我们在使用委托之前,得自定义一个委托类型，再使用这个自定义的委托类型定义一个委托字段或变量。.NET 2.0给我们带来了Action、Func两个泛型委托，.NET3.0给我们带来了Lambda，这一切使得委托的定义和使用变得简单起来。下面的例子中的委托都使用了Lambda表达式。

一.Action系列的泛型委托

Action系列的委托定义的是没有返回值(返回值为void)的委托。它有多个版本包括没有输入参数,1个输入参数,2个输入参数,3个输入参数,4个输入参数共5个版本这几个版本的原型如下:

1.       没有输入参数返回值为void的委托.

Action委托 封装一个方法，该方法不采用参数并且不返回值。

可以使用此委托以参数形式传递一个执行某操作的方法，而不用显式声明一个自定义的委托来封装此方法。该封装的方法必须与此委托定义的方法签名相对应。这意味着该方法不得具有参数和返回值。例:

using System;

using System.Windows.Forms;

public class Name

{

   private string instanceName;

   public Action ShowName;

   public Show()

{

   If(ShowName != null)

    ShowName();

}

   public Name(string name)

   {

      this.instanceName = name;

   }

   public void DisplayToConsole()

   {

      Console.WriteLine(this.instanceName);

   }

   public void DisplayToWindow()

   {

      MessageBox.Show(this.instanceName);

   }

}

public class ActionStudy

{

   public static void Main()

   {

      Name testName = new Name("Koani");

      testName.ShowName  = () => testName.DisplayToWindow();

      testName.Show();

   }

}

2.       有1个输入参数返回值为void的委托

Action<T>泛型委托封装一个方法，该方法只采用一个参数并且不返回值。

可以使用此委托以参数形式传递方法，而不用显式声明自定义的委托。该方法必须与此

委托定义的方法签名相对应。也就是说，封装的方法必须具有一个通过值传递给它的参数，并且不能返回值。例:

using System;

using System.Windows.Forms;

public class ActionStudy

{

   public static void Main()

   {

      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)

         messageTarget = s => MessageBox.Show(s);

      else

         messageTarget = s => Console.WriteLine(s);

      messageTarget("Hello, World!");

   }

}

下面的示例演示如何使用 Action(T) 委托来打印 List(T) 对象的内容。在此示例中，使用 Print 方法将列表的内容显示到控制台上。此外，C# 示例还演示如何使用匿名方法将内容显示到控制台上。

using System;

using System.Collections.Generic;

class Program

{

    static void Main()

    {

        Action<string> PrintInConsole = s => Console.WriteLine(s);

        Action<string> PrintInDialog = s=>MessageBox.Show(s);

        List<String> names = new List<String>();

        names.Add("Bruce");

        names.Add("Alfred");

        names.Add("Tim");

        names.Add("Richard");

        names.ForEach(PrintInConsole);

        names.ForEach(PrintInDialog);      

    }

}

3.       有2个输入参数返回值为void的委托

Action<T1,T2> 封装一个方法，该方法具有两个参数并且不返回值。

可以使用 Action(T1, T2) 委托以参数形式传递方法，而不用显式声明自定义的委托。该

方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有两个均通过值传递给它的参数，并且不能返回值。

using System;

using System.IO;

public class ActinStudy

{

   public static void Main()

  {

      string message1 = "The first line of a message.";

      string message2 = "The second line of a message.";

      Action<string, string>  concat;

      if (Environment.GetCommandLineArgs().Length > 1)

         concat = (s1, s2) =>

{

StreamWriter writer = null; 

      try

      {

         writer = new StreamWriter(Environment.GetCommandLineArgs()[1], false);

         writer.WriteLine("{0}"n{1}", s1, s2);

      }

      catch

      {

         Console.WriteLine("File write operation failed…");

      }

      finally

      {

         if (writer != null) writer.Close();

      }

};

      else

         concat = (s1, s2) => Console.WriteLine("{0}"n{1}", s1, s2);

      concat(message1, message2);

   }

4.       有3个输入参数返回值为void的委托

Action<T1,T2,T3>委托,封装一个方法，该方法采用三个参数并且不返回值。

可以使用 Action(T1, T2, T3) 委托以参数形式传递方法，而不用显式声明自定义的委托。

该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有三个均通过值传递给它的参数，并且不能返回值。

5.       有4个输入参数返回值为void的委托

Action<T1,T2,T3,T4>委托, 封装一个方法，该方法具有四个参数并且不返回值。

可以使用 Action(T1, T2, T3, T4) 委托以参数形式传递方法，而不用显式声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且不能返回值。

二.Func系统的泛型委托

Func系列的委托定义的是返回值的委托。它有多个版本包括没有输入参数,1个输入参数,2个输入参数,3个输入参数,4个输入参数共5个版本这几个版本的原型如下:

1.       没有输入参数有返回值(返回值不为void)的委托

Func<TResult>封装一个不具有参数但却返回 TResult 参数指定的类型值的方法。
可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该

方法必须与此委托定义的方法签名相对应。这意味着封装的方法不得具有参数，但必须返回值。

2.       具有一个输入参数有返回值(返回值不为void)的委托

   Func<T,TResult>封装一个具有一个参数并返回 TResult 参数指定的类型值的方法。

可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有一个通过值传递给它的参数，并且必须返回值。

3.       具有二个输入参数有返回值(返回值不为void)的委托

  Func<T1,T2,TResult>封装一个具有一个参数并返回 TResult 参数指定的类型值的方法。

可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有两个均通过值传递给它的参数，并且必须返回值

4.       具有三个输入参数有返回值(返回值不为void)的委托

   Func<T1,T2,T3,TResut>封装一个具有三个参数并返回 TResult 参数指定的类型值的方法。

可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有三个均通过值传递给它的参数，并且必须返回值。

5.       具有四个输入参数有返回值(返回值不为void)的委托

 Func<T1,T2,T3,TResult>封装一个具有四个参数并返回 TResult 参数指定的类型值的方法。

可以使用此委托构造一个能以参数形式传递的方法，而不用显式声明自定义的委托。该方法必须与此委托定义的方法签名相对应。也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且必须返回值。

1\那就是把 *.iloveyou.io解释到服务器默认网站

2\在项目Global的事件protected void Application_BeginRequest(Object sender, EventArgs e)中通过

   string _path = Request.Url.AbsoluteUri;

   读取当前路径,然后做处理就是了!

   把

   _path="http://liangsan.iloveyou.io/ "

   的路径变为

  newurl="love/?toName=liangsan"

然后通过

    HttpContext.Current.RewritePath(newurl);

 就搞定了!就这么简单!

如何进行ASP.NET MVC 的测试

window对象有两个主要的定时方法，分别是setTimeout 和 setInteval 他们的语法基本上相同，但是完成的功能取有区别。
　 setTimeout方法是定时程序，也就是在什么时间以后干什么。干完了就拉倒。
　 setInterval方法则是表示间隔一定时间反复执行某操作。

　 如果用setTimeout实现setInerval的功能，就需要在执行的程序中再定时调用自己才行(setTimeout( ) 預設只是執行一次, 但我們可以使用一個循環方式, 使到一個setTimeout( ) 再啟動自己一次, 就會使到第二個 setTimeout( ) 執行, 第二個又啟動第三個, 這樣循環下去, 這 setTimeout( ) 就會不斷執行)。如果要清除计数器需要根据使用的方法不同，调用不同的清除方法：

 eg:

    好了,基本原理明白了,剩下的就是自己灵活运用了,可以开发一些定时器或延时器之类的东东^_^.

在做图片刷新功能的时候，会出现IE图片缓存的问题，试了N多方法都没有效果，最后只有使用每刷新一次修改图片文件名加随机数的方法才勉强解决。但是这样 的方法是下次打开浏览器读取图片的时候，上次产生的随机数是动态的，这时候只有让用户关闭浏览器的时候捕捉关闭事件然后将图片更名为一个统一的名字。由于 浏览器是无状态的，在这时候捕捉浏览器关闭会出现两种情况：1.真正的关闭浏览器 2.刷新浏览器。如何判断区分这两种动作呢。
一. JavaScript代码处理方法：
      function window.onbeforeunload()  
      {        
        //用户点击浏览器右上角关闭按钮
        if(event.clientX>document.body.clientWidth&&event.clientY<0||event.altKey)  
        {   
                document.getElementById("btnCompelete").click();
//              window.event.returnValue="确定要退出本页吗?";  
        }
        //用户点击任务栏，右键关闭
        else if(event.clientY > document.body.clientHeight || event.altKey)
        {
            document.getElementById("btnCompelete").click();
//            window.event.returnValue="确定要退出本页吗?";  
        }
         else//其他情况为刷新   
         {   
              alert("你在刷新");
         }  
      } 
其中 event.clientX   鼠标光标X坐标     document.body.clientWidth窗体工作区宽度     event.clientY鼠标光标Y坐标     event.altKey   是否按下alt键
二. 事件捕捉方法：
<body scroll="no" onbeforeunload="return CloseEvent();" onunload="UnLoadEvent()" >
</body>

<script language="JavaScript" type="text/JavaScript"> 
  
    var DispClose = true;
    function CloseEvent()
    {
        if (DispClose)
        {
            return "是否离开当前页面?";
        }
    }
   
    function UnLoadEvent()
    {
        DispClose = false;
        //在这里处理关闭页面前的动作
    }
在页面卸载之前引发onbeforeunload事件，如果用户选择“是”即确定卸载页面将引发onunload事件，否则返回页面不做任何操作。

 在C#中，static变量表示该变量属于类，而不是类的实例。可以说是该类的所有实例共享一个static变量。
ASP.NET的页面就是一个类，我们访问一个页面。就会在服务器上实例化一个该类的实例，来响应我们的请求。
“所有实例共享一个static变量” 这就意味着，所有的客户端访问到的ASP.NET页面中static变量都是同一个变量。

由于我们每次访问ASP.NET页面都是一个全新的对象，而不是我们上一次访问的对象。所以上次页面访问时我们对页面中变量的改动都没有保留。遇到 这个问题的时候，很多初学者的直觉就是将这个变量申明为static，自己在测试的时候发现还真的保留住了页面的状态。窃喜之余没有发现这又有引入了另外 一个错误。因为你要的只是页面能保留住状态，而这个状态是针对一个客户端的（session的效果）。而得到的结果是只要一个客户端改变了该值所有的其他 客户端都受到了影响（如同Applicatin的效果）。这种情况下，需要的极有可能就是个ViewState或者是Session。

Application与static变量
Application是通过一个集合保存所有的对象。

强类型:
Application中保存的是object,对对象的保存和使用需要作cast动作。对于值类型更需要Box&UnBox。对性能的影响较大。
而static变量是强类型的对象。

线程同步:
Application将所有的对象放到一个集合，这样对访问集合中的任何对象都会锁定这个集合。
假如有Application["A"]、Application["B"]、Application["C"],有线程访问Application["A"]其他线程不能访问Application["B"] and Application["C"]。
而static变量，可以根据他们的作用分别放在不同的class当中。这样可以并行访问不同的static变量，而不存在线程安全问题。

友情提示：
1. 对static变量，做lock时。可以通过lock(typeof(classname))来锁定该变量所在的类的类型，达到线程同步的目的。
2. 由于Aplication,static member是全局变量,而我们是在多线程服务器环境写程序，对他们的使用需要注意线程安全的问题

In my previous post I wrote about how we can create our own IControllerFactory for the ASP.NET MVC Framework; in this post I will show you how we can create our own IRouteHandler.
The RouteHandler in this post will replace the IControllerFactory with my own Controller Factory, and also set a default ControllerFactory and a ViewFactory specified in the web.config. This is something the current preview bits of the MVC Framework can’t.
It’s quite easy to create our own RouteHandler, we only need to implement the IRouteHandler interface and implement the GetHttpHandler method 😉
public class N2MVCRouteHandler : IRouteHandler
{
   public IHttpHandler GetHttpHandler(RequestContext requestContext)
   {
       N2MVCHandler handler = new N2MVCHandler();
       handler.RequestContext = requestContext;
       return handler;
    }
}

The GetHttpHandler returns an IHttpHandler. I have created my own IHttpHandler (N2MVCHandler). The N2MVCHandler inherits the MvcHandler shipped with the ASP.NET MVC Framework. The reason why I inherit the MvcHandler is because I don’t want to rewrite stuff that isn’t necessarily. In my IHttpHandler I override the ProcessRequest method and added my own code to create a Controller for the current request.

public class N2MVCHandler : MvcHandler
{
    protected override void ProcessRequest(IHttpContext httpContext)
    {
       if (this.RequestContext == null)
          throw new InvalidOperationException("No RequestContext");

       string controllerName = this.GetRequiredString(this.RequestContext.RouteData, "controller");

       IController controller = this.CreateController(controllerName);
       ControllerContext controllerContext = new ControllerContext(base.RequestContext, controller);

       controller.Execute(controllerContext);
    }

    private IController CreateController(string controllerName)
    {
       N2MVCConfigurationHandler config = ConfigurationManager.GetSection("Nsquared2/N2MVCSection") as N2MVCConfigurationHandler;

       IN2ControllerFactory controllerFactory = N2ControllerFactoryBuilder.GetControllerFactory(config.ControllerFactory);

       IController controller = controllerFactory.CreateController(base.RequestContext, controllerName);

       return controller;
    }
}

In the ProcessRequest method I also create a Controller for the current request by calling the CreateController method. The CreateController method in the N2MvcHandler instantiates a ControllerFactroy which is specified in the web.config file. When the factory is instantiated I make a call to its CreateController method to create an instance of the Controller.

In this example I have replace the IControllerFactory with my own interface, the reason is that I want to pass the name of the Controller and not the Type. The MvcHandler shipped with the MVC Framework will in the ProcessRequest method try to locate the Controller within the references assemblies and create the Type of the Controller and pass it to the IController.CreateController method. But I think it’s up to the ControllerFactory to look up the Controller. Here is my IControllerFactory interface:

public interface IN2ControllerFactory
{
    IController CreateController(RequestContext context, string controllerName);
}

Note: You can still create your own ControllerFactory, but you need to implement my interface instead of IControllerFactory, and you don’t need to make a call to the ControllerBuilder.Current.SetDefaultControllerFactory method in the Application_Start event in Global.asax to specify which ControllerFactory you want to use, instead you can do it in web.config. You will see how to do it later in this post.

I decided to use Spring.Net in this post also to create my Controller within the ControllerFactory.

public class N2ControllerFactory : IN2ControllerFactory
{
    public IController CreateController(RequestContext context, string controllerName)
    {
        IResource input = new FileSystemResource(context.HttpContext.Request.MapPath("objects.xml"));
        IObjectFactory factory = new XmlObjectFactory(input);

        IController controller = (IController)factory.GetObject(controllerName, typeof(IController));

        if (typeof(Controller).IsAssignableFrom(controller.GetType()))
        {
          N2MVCConfigurationHandler config = ConfigurationManager.GetSection("Nsquared2/N2MVCSection") as N2MVCConfigurationHandler;
          ((Controller)controller).ViewFactory = N2ViewFactoryBuilder.GetViewFactory(config.ViewFactory);
        }
        return controller;
    }
}
It's the ControllerFactory's responsibility to create and fill the Controller with all it information it needs. In this case the ViewFactory.

The IViewFactory is used to create a factory which has the responsibility to create a View. Because a Controller don’t need to implement the Controller base class I will in my code use a "code policy". I will check if the created Controller inherits the Controller class, if so I will create a IViewFactory and inject it to the Controller. The IController interface don’t have the ViewFactory property, it’s something we will get from the Controller base class. 

If we take a look again at the CreateContoller method in the IHttpHandler (N2MVCHandler), we can see how I get the ControllerFactory from the web.config

private IController CreateController(string controllerName)
{
    N2MVCConfigurationHandler config = ConfigurationManager.GetSection("Nsquared2/N2MVCSection") as N2MVCConfigurationHandler;

    IN2ControllerFactory controllerFactory = N2ControllerFactoryBuilder.GetControllerFactory(config.ControllerFactory);

    IController controller = controllerFactory.CreateController(base.RequestContext, controllerName);

    return controller;
}

I use some other helper classes in my code to create an instance of the Controller- and ViewFactory specified in the web.config, the code of the helper methods is not relevant for this post. When the public CTP of the MVC Framework is released, you can drop me an e-mail and I can send you my source code.

Here is the config section in the web.config where a conrollerFactory is specified and also a viewFactory. So we can now easy specify our ControllerFactory and ViewFactory in web.config.

<Nsquared2>
    <N2MVCSection
        controllerFactory="MvcApplication.Models.N2ControllerFactory, MvcApplication, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
        viewFactory="MvcApplication.Models.N2ViewFactory, MvcApplication, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
</Nsquared2>

By using the Route objects’ RouteHandler, we can easy change the RouteHandler the MVC Framework should use.

RouteTable.Routes.Add(new Route
{
    Url = "[controller]/[action]/[id]",
    Defaults = new { action = "Index", id = (string)null },
    RouteHandler = typeof(N2MVCRouteHandler)
});

In this post you have seen how we can create our own IRouteHandler, and also replace the ControllerFactory with our own.