Object pooling, part 3

This is the third article in my mini series about object pooling. Be sure to read part 1 and part 2 first.

In this part I’m going to put some of the infrastructure in place that’s needed to handle the list of pooled objects, to make objects available and to allow for them to be put back into the pool.

Initializing the pooled object list

As I don’t want to look at automated object creation just yet, I’ll create a constructor for my pool that allows for a list of pooled objects to be passed in from the outside. The Slot class also needs a constructor that allows me to easily create a Slot for an existing object. These two constructors look like this:

class Slot {
  . . .
  /// 
  /// Constructs a Slot object for a pre-existing pooled type object.
  /// 
  public Slot(T poolObject) {
    if (poolObject == null)
      throw new ArgumentNullException("poolObject");
    this.poolObject = poolObject;
  }
  . . .
}

class Pool {
  . . .
  private Pool( ) {
    pool = new List<Slot>( );
  }

  /// 
  /// Constructs a pool and fills its list of pooled objects with the objects
  /// passed in to this constructor.
  /// 
  public Pool(IEnumerable<T> objects) : this( ) {
    foreach (T entry in objects)
      pool.Add(new Slot(entry));
  }
  . . .
}

As you can see, I’ve added a private constructor to the Pool class that has the purpose of initializing internal fields – I don’t intend to allow the Pool to be created with no parameters at all, so I made that one private.

Getting and releasing objects

I filled the GetObject() and ReleaseObject() methods with some code that will allow for objects to be allocated and released. To make the Pool safe to use from multiple threads, I’m using a lock object. I also introduced a few other helper methods; everything’s here in the code sample:

class Pool {
  . . .
  object poolLock = new object( );

  /// 
  /// Returns a pooled object. After use, the pooled object must be returned to the
  /// pool by calling the ReleaseObject method.
  /// 
  public T GetObject( ) {
    lock (poolLock) {
      Slot unusedSlot = pool.Find(delegate(Slot slot) {
        return !slot.InUse;
      });
      if (unusedSlot != null) {
        unusedSlot.Occupy( );
        return unusedSlot.PoolObject;
      }
    }
    throw new OutOfObjectsException( );
  }

  /// 
  /// Releases an object that was previously fetched from the pool
  /// by a call to the GetObject method.
  /// 
  public void ReleaseObject(T poolObject) {
    lock (poolLock) {
      Slot objectSlot = pool.Find(delegate(Slot slot) {
        return EqualityComparer<T>.Default.Equals(slot.Object, poolObject);
      });
      if (objectSlot != null)
        objectSlot.Release( );
      else 
        throw new ArgumentException("The given object is not part of this pool.");
    }
  }
  . . .
}

class Slot {
  . . .
  /// 
  /// Marks the slot as being in use.
  /// 
  public void Occupy( ) {
    inUse = true;
  }

  /// 
  /// Marks the slot as being available.
  /// 
  public void Release( ) {
    inUse = false;
  }
  . . . 
}

[Serializable]
public class OutOfObjectsException : Exception {
  public OutOfObjectsException( ) { }
  public OutOfObjectsException(string message) : base(message) { }
  public OutOfObjectsException(string message, Exception innerException) : base(message, innerException) { }
  protected OutOfObjectsException(SerializationInfo info, StreamingContext context) : base(info, context) { }
}
Next steps

While the current status is complete in itself and could actually be used to borrow and return objects from the pool, the functionality is severely restricted at this point. The pool doesn’t do enough management work itself, but rather leaves object construction to the outside world. So in the next part I’ll show how the system can be extended to do its own object creation, which will make the pool much better scalable.

Leave a Comment

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s