Suspend a thread until the method and all the threads inside complete work?

Question

I am new to flows, and I was wondering how to use them for evaluation in a non-deterministic state machine.

I have a method that calls another method:

public bool Evaluate2(string s) { accepted = false; ThreadEval(s, StartState); return accepted; } 

variable accepted is a member of the class, and I use it to control when other threads should stop.

 void ThreadEval(string s, State q) { if (s.Length == 0 && q.IsFinal) { accepted = true; return; } bool found = true; State current = q; for (int i = 0; found && !accepted && i < s.Length; i++) { found = false; foreach (Transition t in current.transitions) if (t.symbol == s[i]) { Thread thread = new Thread(new ThreadStart(delegate { ThreadEval(s.Substring(i+1), t.to); })); thread.Start(); found = true; } } } 

Each of my states has a set of transitions. A transition consists of a symbol and the state in which it can go, consuming this symbol. Therefore, if I find a possible transition, I want to create a new thread and examine the rest of the line (without the current character) ...

I currently have 2 problems:

• A “return accepted” is executed before all threads created inside the ThreadEval have completed them. Is there a way to ensure that it does not return until those threads run out? I put Thread.Sleep (200) before returning, and it worked, but 200 ms may not be enough for large lines, and I also do not want to increase the value, so small lines will take longer than they need to be processed.

• The code, as it was, leads to some indexing exception ... I'm 99.999% sure that it is true as it is, but it will only stop crashing if I call a substring that passes the value i instead of i + 1 ... but if I call only with i , it will never reach the end of the line, and depending on the configuration of the machine, it can lead to an infinite loop. I don’t know exactly how streams work, but I suspect that maybe some kind of parallel processing changes the value of i before cutting the substring. How can I assure that whenever I call a new thread, I only drop the current char?

If anyone has suggestions for using threads with more elegance, I would be grateful until the only way I found to pass parameters to the function that the thread was assigned to is to use a delegate.

Answer 1

To block until thread t completes, you can use Thread.Join .

 t.Join(); 

This puts the main thread in IDLE state until thread t terminates. This means that you will need to keep track of all the threads created inside the foreach , and then join them one by one.

It is best to use TPL Task<T> instead of directly using threads. Your code will look something like this:

 Task ThreadEval(string s, State q) { //... List<Task> tasks = new List<Task>(); for (int i = 0; found && !accepted && i < s.Length; i++) { found = false; foreach (Transition t in current.transitions) if (t.symbol == s[i]) { tasks.Add( Task.Run( () => await ThreadEval(s.Substring(i+1), t.to))); found = true; } } return Task.WhenAll(tasks); } await ThreadEval(...); 

• Change the signature to return a Task instead of void
• Create a list of all running tasks
• Task.WhenAll will create a new task that will be marked as complete when all tasks within the tasks list are marked as completed by themselves. Return this task.

Then the caller will be await ThreadEval.

Answer 2

Wrote a small example that will help you understand how this can be done https://dotnetfiddle.net/2Djdh7

Basically, you can use the Join() method to wait for the thread to finish, and using the ForEach() method in the thread list, you can wait for all the threads to finish on the same line.

 public class Program { public static void Main(string[] args) { List<int> list = new List<int>(); list.AddRange(new int[] {10, 200, 300, 400, 234 }); // create a bunch of threads List<Thread> threads = new List<Thread>(); list.ForEach(x => threads.Add(new Thread(() => ThreadMethod(x)))); // start them threads.ForEach(x => x.Start()); // wait for them to finish threads.ForEach(x => x.Join()); // this will not print untill all threads have completed Console.WriteLine("Done"); } private static void ThreadMethod(int i) { Thread.Sleep(i); Console.WriteLine("Thread: " + i); } } 

Output:

 Thread: 10 Thread: 200 Thread: 234 Thread: 300 Thread: 400 Done 

Answer 3

I think async/await patter will help you here. Then you can do something like:

 List<Task> runningEvals = new List<Task>(); async Task ThreadEval(string s, State q) { if (s.Length == 0 && q.IsFinal) { Task.WaitAll(runningEvals.ToArray()); // wait for all tasks to finish runningEvals.Clear(); accepted = true; return; } bool found = true; State current = q; for (int i = 0; found && !accepted && i < s.Length; i++) { found = false; foreach (Transition t in current.transitions) if (t.symbol == s[i]) { // start a task and add it to the "running tasks" list var task = Task.Run(async () => await ThreadEval(s.Substring(i+1), t.to)); runningEvals.Add(task); found = true; } } } 

ATTENTION: This is not verified code (and certainly not a "thread-save" due to a "general List<Task> ), but should only indicate the direction.

This can be called "asynchronous" through:

 await ThreadEval(s, StartState); 

or if you cannot go "asynchronously up" (and only then):

 ThreadEval(s, StartState).Wait();