How to wait for background worker to finish processing?

Question

I have 3 background workers each processing a channel of a 24-bit Bitmap image (Y, Cb, Cr). The processing for each 8-bit image takes several seconds and they might not com

Answer 1

I would use three threads instead of background workers.

using System.Threading;

class MyConversionClass
{
    public YCBCR Input;
    public RGB Output

    private Thread Thread1;
    private Thread Thread2;
    private Thread Thread3;

    private int pCompletionCount;

    public MyConversionClass(YCBCR myInput, RGB myOutput)
    {
        this.Input = myInput;
        this.Output = myOutput;

        this.Thread1 = new Thread(this.ComputeY);
        this.Thread2 = new Thread(this.ComputeCB);
        this.Thread3 = new Thread(this.ComputeCR);
    }

    public void Start()
    {
        this.Thread1.Start();
        this.Thread2.Start();
        this.Thread3.Start();
    }

    public void WaitCompletion()
    {
        this.Thread1.Join();
        this.Thread2.Join();
        this.Thread3.Join();
    }

    // Call this method in background worker 1
    private void ComputeY()
    {
        // for each pixel do My stuff
        ...
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    // Call this method in background worker 2
    private void ComputeCB()
    {
        // for each pixel do My stuff
        ...
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    // Call this method in background worker 3
    private void ComputeCR()
    {
        // for each pixel do My stuff
        ...
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    private void MergeTogether()
    {
        // We merge the three channels together
        ...
    }
}

Now in your code you simply do this:

private void button1_Click(object sender, EventArgs e)
{
    MyConversionClass conversion = new MyConversionClass(myinput, myoutput);
    conversion.Start();
    conversion.WaitCompletion();

    ... your other stuff
}

However this will pause your GUI until all operations are completed. I would use SynchronizationContext instead to notify the GUI that the operation has completed.

This version uses SynchronizationContext for synchronizing the GUI thread without waiting at all. This will keep the GUI responsive and performs the entire conversion operation in the other threads.

using System.Threading;

class MyConversionClass
{
    public YCBCR Input;
    public RGB Output

    private EventHandler Completed;

    private Thread Thread1;
    private Thread Thread2;
    private Thread Thread3;
    private SynchronizationContext SyncContext;

    private volatile int pCompletionCount;

    public MyConversionClass()
    {
        this.Thread1 = new Thread(this.ComputeY);
        this.Thread2 = new Thread(this.ComputeCB);
        this.Thread3 = new Thread(this.ComputeCR);
    }

    public void Start(YCBCR myInput, RGB myOutput, SynchronizationContext syncContext, EventHandler completed)
    {
        this.SyncContext = syncContext;
        this.Completed = completed;
        this.Input = myInput;
        this.Output = myOutput;

        this.Thread1.Start();
        this.Thread2.Start();
        this.Thread3.Start();
    }

    // Call this method in background worker 1
    private void ComputeY()
    {
        ... // for each pixel do My stuff
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    // Call this method in background worker 2
    private void ComputeCB()
    {
        ... // for each pixel do My stuff
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    // Call this method in background worker 3
    private void ComputeCR()
    {
        ... // for each pixel do My stuff
        if (Interlocked.Increment(ref this.CompletionCount) == 3)
            this.MergeTogether();
    }

    private void MergeTogether()
    {
        ... // We merge the three channels together

        // We finish everything, we can notify the application that everything is completed.
        this.syncContext.Post(RaiseCompleted, this);
    }

    private static void RaiseCompleted(object state)
    {
        (state as MyConversionClass).OnCompleted(EventArgs.Empty);
    }

    // This function is called in GUI thread when everything completes.
    protected virtual void OnCompleted(EventArgs e)
    {
        EventHandler completed = this.Completed;
        this.Completed = null;
        if (completed != null)
            completed(this, e);
    }
}

Now, in your code...

private void button1_Click(object sender, EventArgs e)
{
    button1.Enabled = false;

    MyConversionClass conversion = new MyConversionClass();
    conversion.Start(myinput, myoutput, SynchronizationContext.Current, this.conversion_Completed);
}

private void conversion_Completed(object sender, EventArgs e)
{
    var output = (sender as MyConversionClass).Output;
    ... your other stuff that uses output

    button1.Enabled = true;
}

The good things of both method is that they are GUI agnostic, you can put them in a library and keep your precious multi-threading conversion code totally independant on the GUI you are using, that is, WPF, Web or Windows Forms.