Hi All,

I’ve almost got my threaded Consumer/Producer Working using NSThread and friends. However, under certain circumstances, I’m getting objects “stuck” on the queue and the Consumer thread not firing. If I cause it to send another object, then I see the missing object (since it tries to process the whole array each time the ConsumerTask Fires and the New Object.

Here is some code on what I am doing.

Producer Task:

-(void) addObjectToProcessQueue:(id) theNewObject
{
LTWQueueTaskObjectStatusType myStatus;
id myHeadObject;

if (theNewObject == nil)
return;

//**
//** Lock and Get Status
//**
[self.pQueueTaskConsumerTaskWakeUpCondition lock];
myStatus = [self checkObjectIsValid:theNewObject];

//**
//** Check Status
//**
switch (myStatus)
{
case kLTWQueueTaskObjectStatusOverwriteHead:

myHeadObject = [self.pQueueTaskProcessingQueue queueGetHead];

[myHeadObject setDataFrom:theNewObject]; //Just copies properties
[self.pQueueTaskConsumerTaskWakeUpCondition signal];
break;

case kLTWQueueTaskObjectStatusAddToTail:
[self.pQueueTaskProcessingQueue queuePutTail:theNewObject];
[self.pQueueTaskConsumerTaskWakeUpCondition signal];
break;

case kLTWQueueTaskObjectStatusAddToHead:
[self.pQueueTaskProcessingQueue queuePutHead:theNewObject];
[self.pQueueTaskConsumerTaskWakeUpCondition signal];
break;

default:
break;
}

[self.pQueueTaskConsumerTaskWakeUpCondition unlock];
}

---------------------------------------

Consumer Task:

-(void) consumerTask
{
while (YES)
{
[self.pQueueTaskConsumerTaskWakeUpCondition lock];
[self.pQueueTaskConsumerTaskWakeUpCondition wait];

do
{
self.pQueueTaskLastObjectRemoved = [self.pQueueTaskProcessingQueue queueGetHead];
if (self.pQueueTaskLastObjectRemoved != nil)
[self processObject:self.pQueueTaskLastObjectRemoved];
}
while ([self.pQueueTaskProcessingQueue queueGetCount] != 0);

[self.pQueueTaskConsumerTaskWakeUpCondition unlock];
}
}

pQueueTaskConsumerTaskWakeUpCondition is defined as an NSCondition Class. 

I’m using NSCondition, but having problems, I’m confused over this in the in documentation:

"A boolean predicate is an important part of the semantics of using conditions because of the way signaling works. Signaling a condition does not guarantee that the condition itself is true. There are timing issues involved in signaling that may cause false signals to appear. Using a predicate ensures that these spurious signals do not cause you to perform work before it is safe to do so. The predicate itself is simply a flag or other variable in your code that you test in order to acquire a Boolean result. "
 
In my case, the “boolean predicate” is actually the NSArray that holds the objects to process (or more correctly its [NSArray count] != 0), however under certain circumstances, I’m getting objects “stuck” on the queue and the Consumer thread not firing. If I cause it to send another object, then I see the missing object since it tries to process the whole array each time the ConsumerTask Fire.

Looking at the above example - it actually over-signals, since in the case where the object data is overwritten, it has already signalled when the Object was added, however if I don’t signal here, even more objects get “stuck”.

I can’t help thinking from reading the above documentation that this mechanism is a bit hit-and-miss, I can’t remember any other OS/Kernel where I’ve read something like "There are timing issues involved in signaling that may cause false signals to appear.”, and I’m trying to make sense of what it means, it seems to suggest that there may be more signals then expected, whereas I’m seeing less (I think), so it shouldn’t apply?

Anyone have any ideas on how what could be going wrong and how to debug it, I’d love to hear them!

All the Best

Dave

Hi,

Thanks for the sample code Sandor, I’ve now got it working correctly now and I’m really pleased with it. I realised what was wrong just before I went to sleep last night and just added the fix and it works! The major difference in the way your project works is that you have a separate Producer Thread, in my case, a delegate method of the producer task is called with the Data on the Main Thread and you must completely deal with the data it passes before the method returns...

The problem was that it was processing the whole queue with the Condition Locked, so nothing else could get it, this is the revised Consumer Task and it works really well:

-(void) consumerTask
{
while (YES)
        {
        [self.pQueueTaskConsumerTaskWakeUpCondition lock];
        [self.pQueueTaskConsumerTaskWakeUpCondition wait];

//**
//**    Get Head Object - Locked
//**
        self.pQueueTaskLastObjectRemoved = [self.pQueueTaskProcessingQueue queueGetHead];
        [self.pQueueTaskConsumerTaskWakeUpCondition unlock];

//**
//**    Process the Entire Queue
//**
        while (self.pQueueTaskLastObjectRemoved != nil)
                {
//**
//**    Process Object - Unlocked
//**
                [self processObject:self.pQueueTaskLastObjectRemoved];

//**
//**    Get Head Object - Locked
//**
                [self.pQueueTaskConsumerTaskWakeUpCondition lock];
                self.pQueueTaskLastObjectRemoved = [self.pQueueTaskProcessingQueue queueGetHead];
                [self.pQueueTaskConsumerTaskWakeUpCondition unlock];
                }
        }
}

I noticed that your Consumer thread checks “isCancelled”, I’ve added this to my version, although I’m not sure it is needed.

I’ve written this as two generalised classes, a Task Class and a Queue Class, to use it all you need to do is created the Task Object with a Delegate that contains two methods one that is called just before an Object is added to the Queue and one that is called to process the Object. Once I’ve had a chance to tidy it up I’ll send it to anyone that is interested.

Thanks again,
All the Best
Dave

Hi,

Thanks for the sample code Sandor, I’ve now got it working correctly now and I’m really pleased with it. I realised what was wrong just before I went to sleep last night and just added the fix and it works! The major difference in the way your project works is that you have a separate Producer Thread, in my case, a delegate method of the producer task is called with the Data on the Main Thread and you must completely deal with the data it passes before the method returns...

The problem was that it was processing the whole queue with the Condition Locked, so nothing else could get it, this is the revised Consumer Task and it works really well:

-(void) consumerTask
{
while (YES)
        {
        [self.pQueueTaskConsumerTaskWakeUpCondition lock];
        [self.pQueueTaskConsumerTaskWakeUpCondition wait];

//**
//**    Get Head Object - Locked
//**
        self.pQueueTaskLastObjectRemoved = [self.pQueueTaskProcessingQueue queueGetHead];
        [self.pQueueTaskConsumerTaskWakeUpCondition unlock];

//**
//**    Process the Entire Queue
//**
        while (self.pQueueTaskLastObjectRemoved != nil)
                {
//**
//**    Process Object - Unlocked
//**
                [self processObject:self.pQueueTaskLastObjectRemoved];

//**
//**    Get Head Object - Locked
//**
                [self.pQueueTaskConsumerTaskWakeUpCondition lock];
                self.pQueueTaskLastObjectRemoved = [self.pQueueTaskProcessingQueue queueGetHead];
                [self.pQueueTaskConsumerTaskWakeUpCondition unlock];
                }
        }
}

I noticed that your Consumer thread checks “isCancelled”, I’ve added this to my version, although I’m not sure it is needed.

I’ve written this as two generalised classes, a Task Class and a Queue Class, to use it all you need to do is created the Task Object with a Delegate that contains two methods one that is called just before an Object is added to the Queue and one that is called to process the Object. Once I’ve had a chance to tidy it up I’ll send it to anyone that is interested.

Thanks again,
All the Best
Dave