Only when they are finished, the objects are used in the main thread.

How do you make sure they are finished before they are used in the main draw() method because this is the most likely cause of the flickering.
It is probably caused by the draw() method trying to used partially updated data for instance you are changing the x and y positions of something to be drawn the x gets updated then the draw method does its stuff before the y gets updated. There are several mechanisms that can be used to resolove this I will describe the easiest to implement.

Assume we have some data shared by the two methods draw and update, where update is running in a separate thread.

Create a boolean variable called dataLock which is assessable to both threads now in draw we have the code

1. void draw(){
2.       if(dataLock == false){
3.             dataLock = true;       // grab a lock on the data
   
4.             background(0);
5.             // rest of our code goes here
6. 
   
7.             dataLock = false;      // release the lock on the data
   
8.       }
9. }
   

If dataLock is true the draw method is aborted and the screen remains unchanged.


Now the update code is in a separate thread which our sketch has created so we have full control over this.

1. void update(){
2.       while(dataLock == true){
3.             try{
4.                   sleep(10);      // pause this thread for 10 milliseconds
5.             }
6.             catch(Exception excp){
7.             }
8.       }
   
9.       dataLock = true;            // grab control of the data
10.       // update the data
11. 
    
12.       dataLock = false;            // release the lock
13. }
    

If dataLock is true then the data is being drawn so we pause the thread until the data has been released by the draw method before updating it.

Doing it this way means that the update will always get done even if we have to wait a few millis.

This assumes you are creatinng your own classes that extend the Thread class rather than implementing runnable. Personally I prefer extending Thread as it gives you greater flexibility in how you use/ control the thread created.

You have a interesting syntax for the for loop in draw but I managed to sort it out and play with the code.

It seems to work fine in that it runs without causing exceptions, but it all really depends on what you you do inside the run method, provided you are not attempting to draw (e.g. rect(), ellipse() etc) or modify something used for drawing (e.g. stroke(), fill(), rectMode() etc) then I am not sure what is causing your screen flicker.
 

Ok so the run() method draws to the internal graphic buffers and I assume that the draw() method copies part or all of the buffer data to the main screen.

This maybe your problem in that the draw() thread is given control while run() method is part way through updating the graphic buffers. The code you have shown does not prevent this.

Keep the draw methods as before i.e.

1. void draw(){
2.   if(dataLock == false){
3.     dataLock = true;       // grab a lock on the data
4.     background(0);
5. 
   
6.     // can use graphic buffer data
   
7. 
   
8.     dataLock = false;      // release the lock on the data
9.   }
10. }

and change the run method to something like this

1. void run(){
2.   while(thread != null){
3.     while(dataLock == true){
4.       try{
5.         sleep(10);      // pause this thread for 10 milliseconds
6.       }
7.       catch(Exception excp){
8.       }
9.     }
10.     dataLock = true;            // grab control of the data
11. 
    
12.     // update the internal graphic buffers here
13. 
    
14.     dataLock = false;            // release the lock
15.    
16.     // You may want a small delay here for the main
17.     // thread to have a chance to do something
18.     try{
19.        sleep(10);      // pause this thread for 10 milliseconds
20.     }
21.     catch(Exception excp){
22.     }
23.    
24.   } // end while thread
25. }

This will prevent the draw method from executing while the graphic buffers are being updated.

So, unless different PGraphics can "interfere" with each other, I don't seem to be able to find the weak spot.

With all those threads maybe your sketch that gets confused about which 'canvas' it is drawing to?

Using multiple threads is hard enough with standard Java but is more challenging with Processing perhaps someone else has some ideas?

It is interesting that the HSB colorMode caused the problem since I too have had similar issues with some of my sketches  - they will occasionally after some interaction turn all white to blue. As far as I am aware, there are no colorMode calls in the sketches that do this, nor do I explicitly create separate threads (other than have activity in the draw and mouse/keyboard methods that themselves run on different threads).