Interface Reference Counting and Object Lifetime Management in Object Pascal

Author: ikelaiah

Issue: Access Violation Due to Inappropriate Object Freeing

Problem Description#

When passing an object to a method that expects an interface parameter, the object's reference count is increased. Manually freeing the object while this interface reference exists leads to access violations. This is a common pitfall when mixing manual object management with interface reference counting in Object Pascal.

Example of Problematic Code#

procedure TProducerConsumerThreadPool.Queue(AProcedure: TThreadProcedure);
var
  WorkItem: TProducerConsumerWorkItem;
begin
  WorkItem := TProducerConsumerWorkItem.Create(Self);
  try
    WorkItem.FProcedure := AProcedure;
    WorkItem.FItemType := witProcedure;
    TryQueueWorkItem(WorkItem);  // Implicitly converts to IWorkItem, increasing ref count
  except
    on E:Exception do
    begin
      WorkItem.Free;  // WRONG: Manual Free while interface reference exists
      raise;
    end;
  end;
end;

// The method receiving the interface parameter
function TryQueueWorkItem(WorkItem: IWorkItem): Boolean;  // Takes interface parameter

What goes wrong

1. WorkItem object is created
2. Object is passed to TryQueueWorkItem, which expects an IWorkItem interface
3. Implicit conversion to interface increases reference count
4. Exception occurs
5. Exception handler manually frees the object
6. Interface reference still exists with non-zero reference count
7. When interface goes out of scope, it tries to release already-freed object
8. Access violation occurs

Correct Implementation#

procedure TProducerConsumerThreadPool.Queue(AProcedure: TThreadProcedure);
var
  WorkItem: TProducerConsumerWorkItem;
  WorkItemIntf: IWorkItem;
begin
  WorkItem := TProducerConsumerWorkItem.Create(Self);
  WorkItem.FProcedure := AProcedure;
  WorkItem.FItemType := witProcedure;
  WorkItemIntf := WorkItem;  // Explicit interface assignment for clarity
  
  try
    TryQueueWorkItem(WorkItemIntf);
  except
    on E: Exception do
    begin
      DebugLog('TProducerConsumerThreadPool.Queue: Exception caught: ' + E.Message);
      raise;  // No manual Free - let interface handle cleanup
    end;
  end;
end;

Best Practices#

1. Be aware of implicit interface conversions - When passing an object to a method expecting an interface - When assigning an object to an interface variable
2. Never manually free objects that have active interface references
3. Make interface usage explicit for better code clarity
4. Use separate variables when you need both object and interface access
5. Let interface reference counting handle cleanup

Detection#

This issue can be detected through:

1. Unit tests that trigger exceptions during interface operations
2. Access violations occurring after exception handling
3. Memory corruption in complex scenarios
4. Heap corruption reports

Example Test Case That Caught This Issue#

procedure TTestProducerConsumerThreadPool.Test08_QueueFullBehavior;
const
  QUEUE_SIZE = 2;
  THREAD_COUNT = 1;
var
  TestPool: TProducerConsumerThreadPool;
  ExceptionRaised: Boolean;
begin
  TestPool := TProducerConsumerThreadPool.Create(THREAD_COUNT, QUEUE_SIZE);
  try
    // Fill queue to capacity with long-running tasks so the worker cannot
    // drain the queue before the third enqueue is attempted.
    TestPool.Queue(@LongTask);
    TestPool.Queue(@LongTask);

    // This should trigger the exception
    try
      TestPool.Queue(@LongTask);  // Queue is full, will raise EQueueFullException
    except
      on E: EQueueFullException do
        ExceptionRaised := True;
    end;
    
    AssertTrue('Should have raised queue full exception', ExceptionRaised);
  finally
    TestPool.Free;
  end;
end;

Prevention Strategies#

Design Phase#

1. Clear documentation of interface parameter expectations
2. Consistent object lifetime management strategy

Implementation Phase#

1. Make interface conversions explicit
2. Avoid manual object freeing when interfaces are involved
3. Use clear variable naming to indicate interface usage

Testing Phase#

1. Test exception paths thoroughly
2. Include full queue conditions in tests
3. Monitor for memory leaks and access violations

Conclusion#

Understanding when implicit interface conversions occur and their impact on reference counting is crucial for robust Object Pascal applications. The key is to recognize that once an object is referenced by an interface, its lifetime should be managed by the interface reference counting mechanism, not manual freeing.

---

Note: This document is based on real-world experience with a thread pool implementation (ThreadPool.ProducerConsumer) in Object Pascal/Free Pascal.