Multithreading System.Windows.Graphics
c#, gdi+, graphics, multithreading, winforms
Solution
Here's a screen-shot of the concurrency analyzer I used to see what's going on with these threads:
Yes, you can see lots of red (blocking) with flecks of green (execution). The threads are taking turns entering a critical section that's acquired inside the internal GpGraphics::RenderDrawPath() function. The larger blobs of green is where the program actually drew the lines (I replaced DrawEllipse with DrawRectangle and got rid of the Random call).
There is some concurrency, you can for example see the RenderDrawPath() call being overlapped by the code that renders the anti-aliased lines, overall cpu load is around 35%. But there isn't much of it.
Nothing you can do about it of course. You get ahead by overlapping the logic in your own program to decide what to draw with the GDI+ calls. Which will normally happen, the test is too synthetic.
Problem
I know of course that I can not draw onto the same `Graphics` object from different threads, but is it also true that I can not draw to different `Graphics` objects in different threads? Consider the following console program: ``` class Program { static ThreadDrawer[] drawers; static void Main(string[] args) { int numThreads = 8; drawers = new ThreadDrawer[numThreads]; for (int i = 0; i < numThreads; i++) { drawers[i] = new ThreadDrawer(); drawers[i].Start(); } for (int i = 0; i < numThreads; i++) { drawers[i].Wait(); } Console.WriteLine("Complete."); Console.ReadKey(); } class ThreadDrawer { private Thread thread; private AutoResetEvent resetEvent; public ThreadDrawer() { thread = new Thread(DrawRandomCircles); resetEvent = new AutoResetEvent(false); } public void Start() { thread.Start(); } public void Wait() { resetEvent.WaitOne(); } public void DrawRandomCircles() { Random r = new Random(Environment.TickCount); using (Bitmap b = new Bitmap(1000, 1000)) using (Graphics g = Graphics.FromImage(b)) { for (int i = 0; i < 100000; i++) { g.DrawEllipse(Pens.Red, new Rectangle(r.Next(1000), r.Next(1000), 200, 200)); } } resetEvent.Set(); } } } ``` The program creates a `Bitmap` in each thread and proceeds to draw random ellipses on it using a `Graphics` object, also generated per thread from the `Bitmap`. Due to a requirement to build for `.net2` the multithreading is implemented using `Thread`s and `AutoResetEvent`s instead of TPL. The program executes without throwing an exception, but it executes serially. Using `n` threads multiplies execution time by `n` and it is clear to see using the task manager that only one core is being used. Important to take note that none of this is tied to any UI element. What is going on here? Is the `Graphics` object locking on a static object?