How to use multithreading in for loop?

If you are updating multiple databases and the databases are slow to respond, you may consider starting a new thread for each database, rather than starting a single thread that loops through all the databases. This will reduce the total time needed to complete the operations, assuming that the databases are on different servers or on a single server that can scale if it receives multiple queries at the same time (for instance, if it has multiple CPUs and multiple spindles for the database files).

If there are many databases, you will want to establish a limit for the number of updates in progress at a given time, so as not to launch dozens of simultaneous threads.

The async delegate that you are using is reasonable, but is not the only way to launch the threads. A different approach is to create a System.Threading.Thread to start the different threads. This lets you adjust the priority of each thread you are launching. Another possibility, if you are using Sql Server databases, is to use the BeginExecuteNonQuery and similar methods of the SqlCommand object to send the command that updates you databases.

Yes, inside any given thread, including one started by means of an async delegate, you can start another new thread by means any of the alternative methods, including the use of yet another async delegate.

Be careful if you are starting many threads with async delegates, because they use the ThreadPool which has a limit on the number of threads that it can provide to your code.

If there are other thigs being done in the BeginProcess function, and these things operate with class variables, you want to be careful if you launch them in separate threads, in order to avoid race conditions. You will need to add appropriate locking when accessing resources that are shared by several threads. This is not needed when calling the database, since the database itself performs the locking (but you need to use separate Connections unless you are using MARS).

The source where I first learned about multithreading in .Net was Microsoft Official Course 2349, which contains a chapter on this subject, but these MOC courses are only available at significant cost, so this may not be an option for you. Other than that, my only suggestion is to look up the System.Threading namespace in the MSDN library and follow the various links from there.

It's a little bit complex. My first idea would be to start a thread inside of the "for" loop so that each of the database operations would be processed in parallel. Each has its own database connection, so this wouldn't be a problem. However, there are various things that would have to be taken care of.

First, there is your "proc" object that does an "Update" inside the loop. Depending on what this method does inside, it could be unsafe for multithreading, so it would have to be examined and locking applied if needed.

Then, there is all the logging and tracing logic, which is definitely NOT safe for multithreading. For instance, the stringbuilder "sb" where you Append the error messages would get all messed up if two of the threads tried to append messages at the same time. Same thing goes for the various Trace instructions performed in sequence: if two threads execute this code at the same time, your trace will intermix the various writes and indents, producing a result that is not what you expect.

It can all be fixed for multithreaded work by means of carefully placed lock() statements, but it requires detailed consideration. It would be simple if you just wanted to send Sql Commands in parallel to various databases, but the additional code needs to be analyzed for possible impact when ran from several threads.

Also, you would be updating UI elements from the thread inside the loop, namely the textBox1.BackColor. This is not allowed in Windows Forms: The form controls can only be updated from the same thread that created them, so you have to marshall execution accross threads by means of the Invoke method of the Form or Control. This is not terribly complex if you know how to do it, but it adds yet another consideration that you need to keep in mind.

All things considered, I think that it would be best to try to refactor the code so that the database update operations (which are the ones that are slow and that you wish to perform in parallel) are isolated from all the surrounding logic, and wherever this is not possible, add locking around the operations that are not safe for multithreading.

What the Original Poster wanted to accomplish is to send various requests to several database servers at the same time. Sending them in parallel using multiple threads will get the task completed in a time that is similar to the slowest of the responses from the various servers. If the operations are done sequentially, the total time is the sum of the response times of all the servers, which can potentially be much more time than the slowest of them all.

About accessing a Windows control from another thread, do notice that I already warned the OP in a previous message about the requirement to marshall the execution into the thread that created the window by means of the Invoke method.