Inter-thread communication methods between UI thread and worker threads - 2

Inter-thread communication methods for each framework


Here I introduce inter-thread communication method for three most popular UI frameworks

Windows (WTL, MFC) 

• Use WIN32 API PostMessage
• PostMessage(HWND hwnd, UINT id, WPARAM, LPARAM)

Unfortunately, WIN32 is not C++ API but  old C based API therefore when we pass an event object through the WIN32 API PostMessage(), the event object should be reinterpret casted into LPARAM or WPARAM and the receiver also use unsafe typecast to convert from LPARAM or WPARAM into the event object. Additionally the destination, which receives PostMessage event, should have a window handle, HWND or use PostThreadMessage() so that the run-loop may handle the message by itself.

Qt

• Qt has its own runloop and event object
• void QCoreApplication::postEvent ( QObject * receiver, QEvent * event, int priority )

Qt provides a very nice object based event posting method. We can use QEvent class to pass information to the UI thread. if the basic information container that QEvent class provides is not enough to hold the information that you want to post, you can subclass the QEvent class then add methods or member variables which can contain the information you want to send to UI thread.

COCOA

• Use performSelector method 
• - (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait

NSObject, the root class of COCOA, provides a fancy method, performSelectorOnMainThread which can assign the destination object and method, and pass any type of class.

Unified channel for notifications from worker threads to UI thread

All above communication methods have simular behaviors, first the notification messages are stored into one serialized queue, usually called 'message queue', (of course this process is thread safe and considered mutual exclusions among threads) and the main run loop pops the event from the queue and deliver it to the destination. Because the priority jobs of the UI thread is updating UI and processing messages from kernel layer, events from our worker threads could be delayed and it's up to the policy of the run-loop and this policy makes its UIs look move faster.

Because all the requests from worker threads are stored in a single message queue, it is good idea that unify the channel from worker threads to UI threads. If we make several types of events for inter-thread communication, the main run-loop should have branch conditions as many as the count of event types.

The ideal goal is to make the worker thread's runnable base class have its notification procedure to UI thread.

Class Diagram: Event handler for UI thread to handle events from worker thread

Class Diagram: EventTrigger for worker threads

Implementation for each framework

• Implementation with Qt
• Implementation with WTL

• Implementation with Objective-C performSelector method on COCOA Framework

#import "PotalNetThreadChanger.h"

#import 
#include 

@interface PotalNetThreadChanger : NSObject {
@private
    CPortalNetThreadChanger* changer;
}
- (void)toMainThreadByChanger:(CPortalNetThreadChanger*) pChanger withIntValue:(int) intValue;
+ (PotalNetThreadChanger*)default;
@end


@implementation PotalNetThreadChanger

- (id)init
{
    self = [super init];
    if (self) {
        // Initialization code here.
    }
    
    return self;
}

- (void)dealloc
{
    [super dealloc];
    NSLog(@"Objective-C class PotalNetThreadChanger destructed succssfully");
}

- (void) onMainThreadToChanger:(CPortalNetThreadChanger*)pChanger withIntValue:(int)intValue
{
    pChanger->onMainThread(intValue);
}

- (void)onMainThreadWithId:(NSString*)stringValue;
{
    int intValue = [stringValue intValue];
    [self onMainThreadToChanger:changer withIntValue:intValue];    
}

- (void)toMainThreadByChanger:(CPortalNetThreadChanger*) pChanger withIntValue:(int) intValue
{    
    if (![NSThread isMainThread])
    {
        @synchronized(self){
            changer = pChanger;
            // do not use NSString::stringWithFormat method because this thread doesn't have auto release pool!
            NSString* stringValue = [[NSString alloc]initWithFormat:@"%d", intValue];
            [self performSelectorOnMainThread:@selector(onMainThreadWithId:) withObject:stringValue waitUntilDone:YES];
            [stringValue release];
        }
        return;
    }
    [self onMainThreadToChanger:pChanger withIntValue:intValue];
}

+ (PotalNetThreadChanger*)default
{
    static PotalNetThreadChanger* defaultChanger = [[PotalNetThreadChanger alloc]init];
    return defaultChanger;
}
@end

CPortalNetThreadChanger::CPortalNetThreadChanger()
{
    
}
CPortalNetThreadChanger::~CPortalNetThreadChanger()
{
    std::clog << "class CPortalNetThreadChanger destructed successfully" << std::endl;
    [[PotalNetThreadChanger default]release];
}
void CPortalNetThreadChanger::toMainThread(int value)
{
    [[PotalNetThreadChanger default]toMainThreadByChanger:this withIntValue: value];
}