/*
This example demonstrates thread safety using V's concurrency features.
Key points:
- The `SharedData` struct contains a mutable counter that will be accessed by multiple threads.
- The `increment` function increments the counter within a lock to ensure that only one thread
can modify the counter at a time, preventing race conditions.
- In the `main` function, two threads are spawned to increment the shared counter concurrently.
- The `lock` keyword is used to ensure exclusive access to the shared data during modification,
and the `rlock` keyword is used to allow multiple threads to read the data concurrently without
modification.
This ensures that the counter is incremented safely and the final value is printed correctly.
*/

struct SharedData {
mut:
	counter int
}

fn increment(shared data SharedData) {
	lock data {
		data.counter++
	}
}

fn main() {
	shared data := SharedData{}
	threads := [spawn increment(shared data), spawn increment(shared data)]

	for t in threads {
		t.wait() // Wait for both threads to complete
	}

	rlock data {
		println('Counter: ${data.counter}')
	}
}