better/cleaner way to do this _thread lock

[GM-Script-Writer-62850]

I have 1 lock I use as a indicator to tell the second core to hold up I need you to wait a moment, then I use a second lock to tell core 1 you are good to go, then the locks released and the other core gets start going again, trying to read this feels like spaghetti

maybe i just need better variable names? suggestions?

i could just lock and unlock with every sleep call, but seems like unnecessary overhead and core 0 can wait 0.1 seconds or if core 1 is actually busy taking user input, that takes priority and core 0 can wait, but being able to await the 1st lock would be nice...

I have this in my _thread's loop

	if lock.setTime.locked(): # core 0 has work to do
		lock._setTime.release() # let core 0 do work
		lock.setTime.acquire() # wait for core 0 to finish
		lock._setTime.acquire() # get main lock back
		lock.setTime.release() # allow core 0 to get it again

then i have this running on core 0

	lock.setTime.acquire() # tell core 1 we got work to do
	lock._setTime.acquire() # core 1 says we are good to go
	ntptime.settime() # having time.sleep happen on another core when this happens can cause very unexpected and unpredictable behavior
	lock.setTime.release() # tell core 1 we are done
	lock._setTime.release() # allow core 1 to take this back

this is the lock class

class lock:
	setTime=_thread.allocate_lock()
	_setTime=_thread.allocate_lock()

[peterhinch]

I don't see the need for two locks. Assume lock is an instance, on core 0 you might have

def set_time():
    lock.acquire()
    ntptime.settime()
    lock.release()

On core 1

while True:
    lock.acquire()
    # do work that requires a stable clock
    lock.release()
    # Clock might get updated before the next iteration

[GM-Script-Writer-62850]

I managed to make it a bit better...
I wanted core 0 to kindly ask for 1 to stop when you get a chance and have core 0 not be stuck waiting for eternity cause the switch broke and is no longer momentary, if that were to happen it will not crash till it hits a int overflow (would take over 2 billion seconds)

note that i sync time at 1 AM daily (unless wifi is down)

lock class:

class lock:
	flag=0
	lock=_thread.allocate_lock()

Running on core 0

	lock.lock.acquire()
	lock.flag=1
	while lock.flag:
		await sleep(5) # milliseconds BTW
	ntptime.settime()
	lock.lock.release()

Running on core 1:

	if lock.flag:
		lock.flag=0
		lock.lock.acquire() # wait for unlock
		lock.lock.release()