我所理解的Remoting (2) ：远程对象的生命周期管理[下篇]

在上一篇文章中([原创]我所理解的Remoting（2）：远程对象生命周期的管理—Part I )，我简要的讲述了CLR的垃圾回收机制和Remoting 基于Lease的对象生命周期的管理。在这篇文章中，我们将以此为基础，继续我们的话题。在文章的开始，我将以我的理解详细地讲述Remoting中两个重要的概念——Lease和Sponsorship。然后我通过一个Sample，为大家演示如何以不同的方法延长远程对象的生命周期。

我们先不谈远程对象、本地对象。 不管是远程的对象，还是本地对象，都对于程序Application Domain 所在地址空间的一块连续的托管堆（managed heap）内存区域。在.NET环境下，其对象的生命周期，也就是对应托管堆的回收，都由垃圾回收器（garbage collector）负责。当需要进行垃圾回收时（如果不是强制进行垃圾回收，和程序卸载，垃圾回收操作一般出现在第0代对象充满的时候），垃圾回收器扫描托管堆，标记垃圾对象（实际上是标记非垃圾对象，未被标记的则是垃圾对象），并最终回收垃圾对象。

通过前面章节的介绍，我们知道了，CLR通过当前程序运行时的一个根（root）的列表来判断一个对象是否是垃圾对象——没有被根直接或者间接引用的对象则是垃圾对象。从另一个角度讲，如果想让一个对象存活，或者你试图让一个对象具有更长的生命周期，那么不就必须使它被一个根直接或者间接引用——比如你可以使用一个全局变量引用它，那么在这个全局变量的生命周期内，这个对象就会一直存活；你甚至可以让一个静态变量引用它，那么这个对象将永远不会被垃圾回收，直到所在的AppDomain被卸载。而我们现在来讨论Remoting 中远程对象生命周期的管理，说白了，其本质就是在Remoting Framework中，如何创建一些具有根性质的对象引用创建的远程对象（相对于Client端来讲），从而适当地（我们不能让远程对象具有太长的生命周期，那样会见中内存的压力，同样我们也不能使远程对象，那样会造成频繁的对象的频繁创建进而影响系统的性能）阻止垃圾回收器回收该对象。

那么这个引用远程对象的对象是谁呢？它就是我们要讲的Lease。当Client端的Proxy通过Marshal传到Host环境的时候，Remoting Framework 激活对应的远程对象。与此同时，Lease Manager（整个机遇Lease生命周期管理的总负责）会为该远程对象创建对应的Lease，从垃圾回收的角度讲，远程对象有了Lease对象的引用，则可以在垃圾收器的铡刀下得以幸存。但是通过前面的分析，远程对象不能老是存活者，他是具有一定的生命周期的，也就是说，一旦到了该寿终正寝的时候，垃圾回收器就该对他动刀子。而且，这个生命周期应该是可以配置的，系统地设计人员根据具体的程序运作状况，计算出一个合理的生命周期，在部署的时候，通过配置文件为之设定。

那么这样的机制又是如何实现的呢？到现在为止我们知道，远程对象存在的唯一条件就是它的Lease存在，Lease一旦垃圾回收了，那么它的死期也不远了。这样我们就可以通过Lease对象的生命周期来间接地控制远程对象的生命周期。而Lease对象的生命周期是可以配置的。那么现在我们可以把我们的关注点放在如果控制Lease的生命周期上来。在Remoting中，Lease是实现System.Runtime.Remoting.Lifetime. ILease的类的对象。

namespace System.Runtime.Remoting.Lifetime
{
    // Summary:
    //     Defines a lifetime lease object that is used by the remoting lifetime service.
    [ComVisible(true)]
    public interface ILease
    {
        LeaseState CurrentState { get; }
        TimeSpan InitialLeaseTime { get; set; }
        TimeSpan RenewOnCallTime { get; set; }
        TimeSpan SponsorshipTimeout { get; set; }
        void Register(ISponsor obj);        
        void Register(ISponsor obj, TimeSpan renewalTime);        
        TimeSpan Renew(TimeSpan renewalTime);        
        void Unregister(ISponsor obj);
    }
}

了解在托管环境下Lease是怎样一个对象之后，我们来看看，在Remoting中Lease的生命周期是如果决定的。在前面一节我们提到过我们有3种方式来设置Lease 的各个属性（初始的时间：InitialLeaseTime，一个远程调用所能延续的时间：RenewOnCallTime，Lease Manager联系对应的Sponsor的时间：SponsorshipTimeout）——通过Configuration；通过设置LifetimeServices的静态属性（LeaseTime，RenewOnCallTime，LeaseManagerPollTime，SponsorshipTimeout）；同过Override MarshalByRefObj的InitializeLifetimeService。当Lease对象创建之后，Lease Manager会为Lease设置通过上面方式设定的属性。随后Lease Manager会每隔一定的时间（由LeaseManagerPollTime设定）轮询每个Lease，查看Lease是否过期；随着时间的推移，Lease的租期（InitialLeaseTime - Expired time）越来越少。在这期间，Clien端和Server端获得该Lease，调用Renew方法来延长Lease的租期；此外，来自Client端的远程调用也会把Lease的生命周期延长至一个设定的时间（由RenewOnCallTime设定）。

注：只有在Lease的生命周期小于由RenewOnCallTime设定的时间的条件下，远程调用才会对Lease的租期起作用，或者这样说：current lease time = MAX(lease time - expired time,renew on call time)

那么当Lease Manager在获知某个Lease的已经过期？他会做什么样的操作呢？它会马上结束该Lease吗？就像我在上一章所举的租房的例子一样，房东在房租到期之后，出于人性化的考虑，他会首先通知承租人是否有续租的意愿。如果有，可以续约。在Remoting中也存在这样一种状况，Client可以在Lease尚未到期的时候，为他注册一个或多个Sponsor，Lease Manger会首先联系注册到该Lease的Sponsor，如果获得这样的Sponsor，则调用Sponsor的Renewal，从而实现续约的目的。由于Sponsor处于Client端所在的Context，Lease Manager调用Sponsor实际上是一种远程调用，由于远程调用的不确定性，必须设定Lease Manager联系Sponsor的时间范围（由SponsorshipTimeout属性设定），如果超出这样的范围，则认为Sponsor不可得。

在Remoting中，一个Sponsor是一个是实现了System.Runtime.Remoting.Lifetime. ISponsor Interface的类对象。该接口只有一个成员方法：Renewal。还有一点需要特别说明的是，Spnosor是被设计来被处于Server端的Lease Manager调用的。由于这是一个跨AppDomain的调用，我们知道由于AppDomain的隔离性，在一个AppDomain创建的对象不能在另一个Appdomain中直接调用，需要经过一个Marshal的过程——Marshal By Refence 或者 Marshal By Value。我们一般采用Marshal By Refence的方式，我们经常使用的System.Runtime.Remoting.Lifetime.ClientSponsor就是直接继承自System. MarshalByRefObject。

namespace System.Runtime.Remoting.Lifetime
{
    public interface ISponsor
    {        
        TimeSpan Renewal(ILease lease);
    }
}

一旦Lease过期，在既定的时间内，不能获得对应的Sponsor（或者是Sponsor 的Renewal方法返回TimeSpan.Zero），那么Lease Manager就把该Lease标记为过期。如果这时有一个远程调用，Remoting Framework会通过Lease Manager得知Lease已经过期，如果Client Activation模式直接会抛出异常；如果是Singleton 模式的Server Activation，则会创建一个新的对象，原来对象的状态将不复存在。这里有一点需要特别注意的是，Lease Manager就把该Lease标记为过期,并不等于该Lease马上会被垃圾回收掉，同理，这时候虽然远程对象可能还是存在的，由于这时候我们不能保证调用的安全性——不能确定该对象什么时候被垃圾回收，对于远程调用来说，它已经没有任何意义。

从上面整个流程来看，为了保持远程对象，我们有Lease对象；为了保持Lease对象，我们有Sponsor对象，那么什么对象来保持Sponsor对象呢？那就要依赖于我们的Client代码了。如果注册的Sponsor对象如果一直不被回收的话，远程对象将永远存在。所以我们应该根据实际的需要，取消Sponsor对Lease的注册。

下面我们照例来展示一个Sample，在这个Sample中，我们设计一个计数器，获得某个对象某个方法的调用次数。

Step 1 ：整个Solution的构架(Artech.LifetimeManagement.RemoteService被Artech.LifetimeManagement.Client和Artech.LifetimeManagement.Hosting引用)

Step 2：远程对象Artech.LifetimeManagement.RemoteService/CounterService.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting.Lifetime;

namespace Artech.LifetimeManagement.RemoteService
{
    public class CounterService:MarshalByRefObject
    {
        private int _count;

        public int GetCount()
        {
            this._count++;
            return this._count;
        }
        public CounterService()
        {
            Console.WriteLine("Counter Object has been activated!");
        }
        ~CounterService()
        {
            Console.WriteLine("Counter Object has been destroied!");
        }
        public override object InitializeLifetimeService()
        {
            ILease lease = (ILease)base.InitializeLifetimeService();
            if (lease.CurrentState == LeaseState.Initial)
            {
                lease.InitialLeaseTime = TimeSpan.FromSeconds(1);
                lease.RenewOnCallTime = TimeSpan.FromSeconds(1);
                lease.SponsorshipTimeout = TimeSpan.FromSeconds(1);
            }
            return lease;
        }
    }
}

为了确定对象的创建和回收，我们定义了Constructor和重写了 Finalize方法。GetCouter是 远程调用的方法，每次调用，技术器一次递增并返回该计数。为了更容易地演示对象的生命周期，我们重写了InitializeLifetimeService，设置了一些列短时间的Lease属性（都为1s）。

Step 3 Host : Artech.LifetimeManagement.Hosting

App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.runtime.remoting>
    <application name="Artech.MyRemoting">
      <service>
        <wellknown type="Artech.LifetimeManagement.RemoteService.CounterService,Artech.LifetimeManagement.RemoteService"
                  mode="Singleton" objectUri="Counter.rem"></wellknown>
        <activated type="Artech.LifetimeManagement.RemoteService.CounterService,Artech.LifetimeManagement.RemoteService"></activated>
      </service>
      <channels>
        <channel type="System.Runtime.Remoting.Channels.Http.HttpChannel,System.Runtime.Remoting, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
                 port ="1234">
          <serverProviders>
            <provider ref="wsdl" />
            <formatter ref="binary" typeFilterLevel="Full" />
          </serverProviders>
          <clientProviders>
            <formatter ref="binary" />
          </clientProviders>
        </channel>
      </channels>
    </application>
  </system.runtime.remoting>
</configuration>

我定义了两个Service，一个WellKnown Service，一个CAO Service。因为我们将同时比较两种不同激活方式的生命周期的管理。在前面我们不止一次地说，调用Sponsor是一种远程调用，说得更确切地，只一种远程回调（Remote Callback），所以我们要把Type Filter Level设为Full，其原因可以参考我们文章（[原创].NET Remoting: 如何通过Remoting实现双向通信（Bidirectional Communication）），在这里就不再说明。

Program.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Runtime.Remoting;

namespace Artech.LifetimeManagement.Hosting
{
    class Program
    {
        static void Main(string[] args)
        {
            RemotingConfiguration.Configure("Artech.LifetimeManagement.Hosting.exe.config", false);
            Console.WriteLine("Calculator has begun to listen  ");
            GarbageCollect();
            Console.Read();
        }

        static void GarbageCollect()
        {
            while (true)
            {
                Thread.Sleep(10000);                
                GC.Collect();
            }
        }
    }
}

通过上面的Code，我们先注册App.config的配置，为了更加清楚地看清对象的回收时间，我们每隔10s作一次垃圾回收。

Step 4 Client：Artech.LifetimeManagement.Client

App.config

<configuration>
  <system.runtime.remoting>
    <application>
      <channels>
        <channel ref="http" port="0">
          <clientProviders>
            <formatter ref="binary" />
          </clientProviders>
          <serverProviders>
            <formatter ref="binary" typeFilterLevel="Full" />
          </serverProviders>
        </channel>
      </channels>
    </application>
  </system.runtime.remoting>
</configuration>

由于处于Server端的Lease Manager要CallbackClient端的Sponsor，Client端必须注册一个Channel用于回调。同样把Type Filter Level设为Full。

Program.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using Artech.LifetimeManagement.RemoteService;
using System.Threading;
using System.Runtime.Remoting.Lifetime;

namespace Artech.LifetimeManagement.Client
{
    class Program
    {
        const int _invocationFrequency = 4;

        static void Main(string[] args)
        {
           RemotingConfiguration.Configure("Artech.LifetimeManagement.Client.exe.config", false);
            RemotingConfiguration.RegisterActivatedClientType(typeof(CounterService), "http://localhost:1234/Artech.MyRemoting");

            CounterService singletonCounter = Activator.GetObject(typeof(CounterService),"http://localhost:1234/Artech.MyRemoting/Counter.rem")
                 as CounterService;
            CounterService caoCounter = new CounterService();

            Thread singletonThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));
            Thread caoThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));

            singletonThread.Name = "Singleton";
            caoThread.Name = "CAO";
            
            singletonThread.Start(singletonCounter);
            caoThread.Start(caoCounter);
           
        }

        static void InvocateCounterService(object counter)
        {
            CounterService counterService = counter as CounterService;
            while (true)
            {
                try
                {
                    Console.WriteLine("{1}: The count is {0}", counterService.GetCount(), Thread.CurrentThread.Name.PadRight(10));
                    Thread.Sleep(_invocationFrequency * 1000);
                }
                catch (Exception ex)
                {
                    if (Thread.CurrentThread.Name == "Singleton")
                    {
                        Console.WriteLine("Fail to invocate Singleton counter because \"{0}\"", ex.Message);
                        break;
                    }

                    if (Thread.CurrentThread.Name == "CAO")
                    {
                        Console.WriteLine("Fail to invocate CAO counter because \"{0}\"", ex.Message);
                        break;
                    }

                }                         
            }
        }        
    }
}

通过上上面的Code，我首先创建了连个Proxy，一个Singleton和一个CAO。然后创建连个线程，并在这两个线程中以固定的时间间隔（4s:_ invocationFrequency = 4）通过这两个Proxy进行远程调用。

现在我们来看看运行的结果：

启动Hosting：

启动Client，等待一段时间：

再来看Host现在的显示：

我们可以看到，对于Singleton Proxy，调用没有出现异常，但是调用的计数器不没有维持一个持续的增长——从1到3，然后又从1-3，这样周而复始，这就证明了，没3次调用的远程对象不是同一个，当Lease过期之后，一个新的远程对象被创建。从Host 的输出也验证了这点，远程对象在不断地被创建。还有一个有意思的是，调用了3次Constructor之后才开始调用Finalizer方法，这说明了什么呢？这说明了，Lease过期后的调用，会导致新的远程对象的创建，但实际上这是，该远程对象还没有被回收。它在连续创建了3个新的对象后，才真正被垃圾回收。

而对于CAO Proxy，则不同，在第4次调用时，出现Exception，这Lease过期，再调用某个远程方法，会直接抛出Exception。

1．通过远程调用来延长远程对象的生命周期

通过我们开始的分析，在Lease的租约小于renew on call time，远程调用会使租约延长。按照这样理论，如果我们提高远程调用的频率，我们可以延长远程对象的生命周期。基于这样的想法，我们把效用的时间间隔从原来的4缩短为1s（_ invocationFrequency = 1）。再次运行。

Client端：


Host：

正如我们想得一样，无论是对于Singleton Proxy还是CAO Proxy，计数器一直维持一个持续增加的趋势，并且没有Exception抛出。从Client端就可以看出，Singleton Proxy和CAO Proxy调用的始终是一个远程对象，而Host的输出更是确凿地证明了，从始到终，只有连个对象被创建，一个对于Singleton，另一个对于CAO。

2．通过Lease来延长生命周期

上面我们通过远程调用来延长远程对象的生命周期，现在我们采用另一种方法，直接利用Lease对象来延长远程对象的生命周期。我们改动Client的代码：

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using Artech.LifetimeManagement.RemoteService;
using System.Threading;
using System.Runtime.Remoting.Lifetime;

namespace Artech.LifetimeManagement.Client
{
    class Program
    {
        const int _invocationFrequency = 4;
        const int _leaseRenewalFrequency = 1;

        static void Main(string[] args)
        {
           RemotingConfiguration.Configure("Artech.LifetimeManagement.Client.exe.config", false);
            RemotingConfiguration.RegisterActivatedClientType(typeof(CounterService), "http://localhost:1234/Artech.MyRemoting");

            CounterService singletonCounter = Activator.GetObject(typeof(CounterService),"http://localhost:1234/Artech.MyRemoting/Counter.rem")
                 as CounterService;
            CounterService caoCounter = new CounterService();

            Thread singletonThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));
            Thread caoThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));

Thread singletonLeaseRennewal = new Thread(new ParameterizedThreadStart(ExtendLifetimeViaLease));
            Thread caoLeaseRenewal = new Thread(new ParameterizedThreadStart(ExtendLifetimeViaLease));

            singletonThread.Name = "Singleton";
            caoThread.Name = "CAO";
            
            singletonThread.Start(singletonCounter);
            caoThread.Start(caoCounter);

  singletonLeaseRennewal.Start(singletonCounter);
            caoLeaseRenewal.Start(caoCounter);
           
        }

static void ExtendLifetimeViaLease(object counter)
        { 
            CounterService counterService = counter as CounterService;
            ILease lease = (ILease)RemotingServices.GetLifetimeService(counterService);
            while (true)
            {
                if (lease == null)
                {
                    Console.WriteLine("Can not retrieve the lease!");
                    break;
                }

                lease.Renew(TimeSpan.FromSeconds(_leaseRenewalFrequency));
                Thread.Sleep(_leaseRenewalFrequency);
            }
        }

        static void InvocateCounterService(object counter)
        {
            CounterService counterService = counter as CounterService;
            while (true)
            {
                try
                {
                    Console.WriteLine("{1}: The count is {0}", counterService.GetCount(), Thread.CurrentThread.Name.PadRight(10));
                    Thread.Sleep(_invocationFrequency * 1000);
                }
                catch (Exception ex)
                {
                    if (Thread.CurrentThread.Name == "Singleton")
                    {
                        Console.WriteLine("Fail to invocate Singleton counter because \"{0}\"", ex.Message);
                        break;
                    }

                    if (Thread.CurrentThread.Name == "CAO")
                    {
                        Console.WriteLine("Fail to invocate CAO counter because \"{0}\"", ex.Message);
                        break;
                    }

                }                         
            }
        }        
    }
}

在上面的代码中，我通过ExtendLifetimeViaLease方法每个一定的时间（1s：_leaseRenewalFrequency = 1）对获得的Lease Renew 一次。  

static void ExtendLifetimeViaLease(object counter)
        { 
            CounterService counterService = counter as CounterService;
            ILease lease = (ILease)RemotingServices.GetLifetimeService(counterService);
            while (true)
            {
                if (lease == null)
                {
                    Console.WriteLine("Can not retrieve the lease!");
                    break;
                }

                lease.Renew(TimeSpan.FromSeconds(_leaseRenewalFrequency));
                Thread.Sleep(_leaseRenewalFrequency);
            }
        }

象原来的例子一样，分别在连个线程中以一定时间间隔（4s）调用远程对象，不过这次我们创建两个新的线程不同对Lease进行Renew，这样确保Lease用不过期。实验证明，输出结果和上面完全一样。

3．通过Sponsor来延长生命周期 

不说废话直接来看代码：

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Remoting;
using Artech.LifetimeManagement.RemoteService;
using System.Threading;
using System.Runtime.Remoting.Lifetime;

namespace Artech.LifetimeManagement.Client
{
    class Program
    {
        const int _invocationFrequency = 4; 
        static ISponsor _singletonSponsor;
        static ISponsor _caoSponsor;

        static void Main(string[] args)
        {
            RemotingConfiguration.Configure("Artech.LifetimeManagement.Client.exe.config", false);
            RemotingConfiguration.RegisterActivatedClientType(typeof(CounterService), "http://localhost:1234/Artech.MyRemoting");
            CounterService singletonCounter = Activator.GetObject(typeof(CounterService),"http://localhost:1234/Artech.MyRemoting/Counter.rem")
                 as CounterService;
            CounterService caoCounter = new CounterService();

            Thread singletonThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));
            Thread caoThread = new Thread(new ParameterizedThreadStart(InvocateCounterService));            

            singletonThread.Name = "Singleton";
            caoThread.Name = "CAO";
            
            singletonThread.Start(singletonCounter);
            caoThread.Start(caoCounter);

            _singletonSponsor = ExtendLifetimeViaSponsor(singletonCounter);
            _caoSponsor = ExtendLifetimeViaSponsor(caoCounter);
           
        }

        static void InvocateCounterService(object counter)
        {
            CounterService counterService = counter as CounterService;
            while (true)
            {
                try
                {
                    Console.WriteLine("{1}: The count is {0}", counterService.GetCount(), Thread.CurrentThread.Name.PadRight(10));
                    Thread.Sleep(_invocationFrequency * 1000);
                }
                catch (Exception ex)
                {
                    if (Thread.CurrentThread.Name == "Singleton")
                    {
                        Console.WriteLine("Fail to invocate Singleton counter because \"{0}\"", ex.Message);
                        break;
                    }

                    if (Thread.CurrentThread.Name == "CAO")
                    {
                        Console.WriteLine("Fail to invocate CAO counter because \"{0}\"", ex.Message);
                        break;
                    }

                }                         
            }
        }


        static ISponsor ExtendLifetimeViaSponsor(CounterService counter)
        {
            CounterService counterService = counter as CounterService;
            ILease lease = (ILease)RemotingServices.GetLifetimeService(counterService);
            ClientSponsor sponsor = new ClientSponsor(TimeSpan.FromSeconds(4));
            sponsor.Register(counterService);
            return sponsor;
        }
    }
}

上面的代码中，我通过ExtendLifetimeViaSponsor方法为Lease注册一个Sposnor，并把Renew时间设为4s，最后把该Sposnor负值给一个静态变量，这样他不会被垃圾回收。那么每次Lease Manager获得该Sponsor时候，会自动把Lease 的租期变为4s。这样远程对象将会永久存活。可以想象，输出结果将会和上面一样。

相关章节：
[原创]我所理解的Remoting（1）：Marshaling & Activation - Part I
[原创]我所理解的Remoting（1）：Marshaling & Activation - Part II
[原创]我所理解的Remoting（2）：远程对象生命周期的管理—Part I
[原创]我所理解的Remoting (2) ：远程对象的生命周期管理-Part II
[原创]我所理解的Remoting(3):创建CAO Service Factory使接口和实现相互分离
[原创].NET Remoting: 如何通过Remoting实现双向通信（Bidirectional Communication）