Starting and managing threads

[Tejas]

On Tuesday, 28 December 2021 at 14:19:46 UTC, Bagomot wrote:
> On Monday, 27 December 2021 at 10:59:07 UTC, Ali Çehreli wrote:
>> On 12/27/21 1:33 AM, Bagomot wrote:
>>
>> > separate thread, without blocking the main one.
>>
>> I think you can use std.concurrency there. I have a chapter 
>> here:
>>
>>   http://ddili.org/ders/d.en/concurrency.html
>>
>> Look for 'struct Exit' to see how the main thread signals 
>> workers to stop running.
>>
>> And some std.concurrency hints appear in my DConf Online 2020 
>> presentation here:
>>
>>   https://dconf.org/2020/online/#ali1
>>
>> Ali
>
> I tried to run with std.concurrency via spawn, but this does 
> not work for me for the reason that in the program I run the 
> thread not from main, but from the object. It looks something 
> like this:
>
> ```d
> import std.concurrency;
> import std.thread;
>
> void main() {
> 	Test.getInstance.run;
> }
>
> class Test {
> 	private {
> 		__gshared Test instance;
> 		Watcher[] watchers;
> 	}
>
> 	protected this() {
> 	}
>
> 	public static Test getInstance() {
> 		if (!instance) {
> 			synchronized (Test.classinfo) {
> 				if (!instance)
> 					instance = new Test;
> 			}
> 		}
>
> 		return instance;
> 	}
>
> 	public void run() {
> 		foreach (Watcher watcher; this.watchers) {
> 			spawn(&watcher.run);
> 		}
> 	}
> }
>
> class Watcher {
> 	public void run() {
> 		while (true) {
> 			// job
> 		}
> 	}
> }
> ```
> Error: template `std.concurrency.spawn` cannot deduce function 
> from argument types `!()(void delegate())`.
>
> I would not want to do this from main because it breaks the 
> structure of my program. Is there a way to do it the way I want?


Yes, you'll have to make the function that you want to run static 
and all the arguments must be `shared` qualified, ie, TLS not 
allowed
```d

import std.concurrency;
import core.thread;
import std.stdio:writeln;

void main() {
	Test.getInstance.run;
}

class Test {
	private {
		__gshared Test instance;
		shared Watcher[] watchers = [new Watcher(), new Watcher()]; 
//notice the shared // I used 2 values just to show some output
	}

	protected this() {
	}

	public static Test getInstance() {
		if (!instance) {
			synchronized (Test.classinfo) {
				if (!instance)
					instance = new Test;
			}
		}

		return instance;
	}

	public void run() {
		foreach (ref/+use ref to ensure no copies are made. I don't 
tknow the right thing to do here, the errors went away when I 
used ref so...+/ watcher; this.watchers) {
			spawn(&Watcher.run, watcher);
		}
	}
}

class Watcher {
	static public void run(shared Watcher watcher/+sending as 
argument since function can't have an invisible this parameter 
anymore+/) {//now this is static
		while (true) {
			// job
       writeln("It works now :D");
       break; //wrote this so that you can copy-paste to 
run.dlang.io
		}
	}
}
```