远程对象的声明周期
2013-10-24 15:13
281 查看
在上一篇文章中([原创]我所理解的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。这样远程对象将会永久存活。可以想象，输出结果将会和上面一样。
基于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。这样远程对象将会永久存活。可以想象，输出结果将会和上面一样。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- spring bean对象的声明周期
- Parsley 开发指南 8 对象声明周期
- symbian os 应用程序中活动对象的声明周期的简要分析
- spring框架中的bean对象的声明周期
- 异性对象声明周期
- 关于对象声明周期的总结
- 远程对象的生存周期问题（flex中的对象的生存周期和服务端的周期是一样的么?）
- 对象的声明周期
- 详解C++编程中类的声明和对象成员的引用
- Fragment声明周期 开发遇到的问题
- Kotlin学习之-5.11 对象表达式和声明
- Xamarin XAML语言教程对象元素的声明方式
- Thin的DateChooser代码学习(关于js的函数参数为一个完整的函数以及“对象不支持此属性或方法”错误的解决)（原创，转载请声明）
- JAVA基础语法、面向对象、了解java对象的生存周期（Object、修饰符、数组、枚举、接口、抽象类）
- 声明指针对象 不会隐式调用构造函数
- 关于Java的泛型在所声明的对象中如何获取class或者实例的方法的总结
- 基于Java class对象说明、Java 静态变量声明和赋值说明(详解)
- 访问远程Java对象 remoteObject
- 关于 对象的声明 及 指针对象
- javascript-声明对象及其属性和方法