InversionOfControl/Castle.MicroKernel/Lifestyle/Pool/DefaultPool.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MicroKernel.Lifestyle.Pool
  16 {
  17         using System;
  18         using System.Threading;
  19         using System.Collections;
  20
  21         using Castle.Core;
  22
  23         [Serializable]
  24         public class DefaultPool : IPool, IDisposable
  25         {
  26                 private readonly Stack available = Stack.Synchronized(new Stack());
  27                 private readonly IList inUse = ArrayList.Synchronized(new ArrayList());
  28                 private readonly int initialsize;
  29                 private readonly int maxsize;
  30                 private readonly ReaderWriterLock rwlock;
  31                 private readonly IComponentActivator componentActivator;
  32
  33                 public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
  34                 {
  35                         this.initialsize = initialsize;
  36                         this.maxsize = maxsize;
  37                         this.componentActivator = componentActivator;
  38
  39                         this.rwlock = new ReaderWriterLock();
  40
  41                         // Thread thread = new Thread(new ThreadStart(InitPool));
  42                         // thread.Start();
  43                         InitPool();
  44                 }
  45
  46                 #region IPool Members
  47
  48                 public virtual object Request(CreationContext context)
  49                 {
  50                         rwlock.AcquireWriterLock(-1);
  51
  52                         object instance = null;
  53
  54                         try
  55                         {
  56
  57                                 if (available.Count != 0)
  58                                 {
  59                                         instance = available.Pop();
  60
  61                                         if (instance == null)
  62                                         {
  63                                                 throw new PoolException("Invalid instance on the pool stack");
  64                                         }
  65                                 }
  66                                 else
  67                                 {
  68                                         instance = componentActivator.Create(context);
  69
  70                                         if (instance == null)
  71                                         {
  72                                                 throw new PoolException("Activator didn't return a valid instance");
  73                                         }
  74                                 }
  75
  76                                 inUse.Add(instance);
  77                         }
  78                         finally
  79                         {
  80                                 rwlock.ReleaseWriterLock();
  81                         }
  82
  83                         return instance;
  84                 }
  85
  86                 public virtual void Release(object instance)
  87                 {
  88                         rwlock.AcquireWriterLock(-1);
  89
  90                         try
  91                         {
  92                                 if (!inUse.Contains(instance))
  93                                 {
  94                                         throw new PoolException("Trying to release a component that does not belong to this pool");
  95                                 }
  96
  97                                 inUse.Remove(instance);
  98
  99                                 if (available.Count < maxsize)
 100                                 {
 101                                         if (instance is IRecyclable)
 102                                         {
 103                                                 (instance as IRecyclable).Recycle();
 104                                         }
 105
 106                                         available.Push(instance);
 107                                 }
 108                                 else
 109                                 {
 110                                         // Pool is full
 111                                         componentActivator.Destroy(instance);
 112                                 }
 113                         }
 114                         finally
 115                         {
 116                                 rwlock.ReleaseWriterLock();
 117                         }
 118                 }
 119
 120                 #endregion
 121
 122                 #region IDisposable Members
 123
 124                 public virtual void Dispose()
 125                 {
 126                         // Release all components
 127
 128                         foreach(object instance in available)
 129                         {
 130                                 componentActivator.Destroy(instance);
 131                         }
 132                 }
 133
 134                 #endregion
 135
 136                 /// <summary>
 137                 /// Initializes the pool to a initial size by requesting
 138                 /// n components and then releasing them.
 139                 /// </summary>
 140                 private void InitPool()
 141                 {
 142                         ArrayList tempInstance = new ArrayList();
 143
 144                         for(int i=0; i < initialsize; i++)
 145                         {
 146                                 tempInstance.Add(Request(CreationContext.Empty));
 147                         }
 148
 149                         for(int i=0; i < initialsize; i++)
 150                         {
 151                                 Release(tempInstance[i]);
 152                         }
 153                 }
 154         }
 155 }