import sync
import time

struct St {
mut:
    a int
}

fn (shared x St) f(shared z St) {
    for _ in 0 .. reads_per_thread {
        rlock x { // other instances may read at the same time
            time.sleep(time.millisecond)
            assert x.a == 7 || x.a == 5
        }
    }
    lock z {
        z.a--
    }
}

fn g() shared St {
shared  x := St{a: 12 }
        return   x
}

fn h() ?shared St {
    return error('no value')
}

fn k() {
  shared  x := g()
  shared y := h() or {
      shared f := St{}
      f
     }
     shared z := h()?
     shared p := v
     v := rlock  z {  z.a }
     rlock x; lock y, z; rlock p {
      z.a = x.a + y.a
      }
     println(v)
}

const (
    reads_per_thread = 30
    read_threads     = 10
    writes           = 5
)

fn test_shared_lock() {
    // object with separate read/write lock
shared x := &St {
a: 5
}
    shared z :=
&St{
        a: read_threads
          }
    for  _  in 0.. read_threads {
        spawn x.f(shared z)
    }
      for  i in 0..writes {
 lock x { // wait for ongoing reads to finish, don't start new ones
             x.a = 17 // this value should never be read
    time.sleep(50* time.millisecond)
    x.a = if (i & 1) ==  0 {    7 } else {  5  }
    } // now new reads are possible again
time.sleep(20*time.millisecond)
    }
    // wait until all read threads are finished
for finished:=false;; {
    mut rr := 0
          rlock z {
  rr = z.a
      finished = z.a == 0
}
if finished {
        break
             }
            time.sleep(100*time.millisecond)
            }
}