Question: I've gone through [this SO question](https://stackoverflow.com/questions/246058/system-invalidoperationexception-the-object-is-currently-in-use-elsewhere-ho) but it didn't help.

The case here is different. I'm using Backgroundworkers. 1st backgroundworker starts operating on the image input of user and inside firstbackgroundworker\_runworkercompleted() I'm using calling 3 other backgroundworkers 

```
 algo1backgroundworker.RunWorkerAsync();
 algo2backgroundworker.RunWorkerAsync();
 algo3backgroundworker.RunWorkerAsync();

```

this is the code for each:

```
algo1backgroundworker_DoWork()
{
 Image img = this.picturebox.Image;
 imgclone = img.clone();
 //operate on imgclone and output it
}

algo2backgroundworker_DoWork()
{
 Image img = this.picturebox.Image;
 imgclone = img.clone();
 //operate on imgclone and output it
}

```

similar operations are done in other algo\*backgrougrondworker\_doWork().

Now SOMETIMES I'm getting "InvalidOperationException - object is currently in use elsewhere". Its very arbitrary. I somtimes get this in algo1backgroundworker\_DoWork and sometimes in algo2backgroundworker\_DoWork and sometimes in Application.Run(new myWindowsForm());

I've no clue about whats happening.

Answer: 
There's a lock inside GDI+ that prevents two threads from accessing a bitmap at the same time. This is not a blocking kind of lock, it is a "programmer did something wrong, I'll throw an exception" kind of lock. Your threads are bombing because you are cloning the image (== accessing a bitmap) in all threads. Your UI thread is bombing because it is trying to draw the bitmap (== accessing a bitmap) at the same time a thread is cloning it.

You'll need to restrict access to the bitmap to only one thread. Clone the images in the UI thread before you start the BGWs, each BGW needs its own copy of the image. Update the PB's Image property in the RunWorkerCompleted event. You'll lose some concurrency this way but that's unavoidable.
So it looks like your BackgroundWorkers are trying to access the same Windows Forms components at the same time. This would explain why the failure is random.

You'll need to make sure this doesn't happen by using a `lock`, perhaps like so:

```
private object lockObject = new object();

algo1backgroundworker_DoWork()
{
    Image imgclone;
    lock (lockObject)
    {
        Image img = this.picturebox.Image;
        imgclone = img.clone();
    }

    //operate on imgclone and output it
}

```

Note that I make sure that imgclone is local to this method - you definitely don't want to share it across all the methods!

On the other hand the same lockObject instance is used by all the methods. When a BackgroundWorker method enters its `lock{}` section, others that come to that point will be blocked. So it's important to make sure that the code in the locked section is fast.

When you come to "output" your processed image, be careful too to make sure that you don't do a cross-thread update to the UI. Check [this post](https://stackoverflow.com/questions/711408/best-way-to-invoke-any-cross-threaded-code) for a neat way to avoid that.