sync

DestroyMutex("mut")
mut, err := NewMutex("mut", os.O_CREATE|os.O_EXCL, 0666)
if err != nil {
	panic("new")
}
defer mut.Close()
DestroyCond("cond")
cond, err := NewCond("cond", os.O_CREATE|os.O_EXCL, 0666, mut)
if err != nil {
	panic("new")
}
defer cond.Close()
var sharedValue int
go func() {
	mut.Lock()
	defer mut.Unlock()
	sharedValue = 1
	cond.Signal()
}()
mut.Lock()
defer mut.Unlock()
if sharedValue == 0 {
	cond.Wait()
	if sharedValue == 0 {
		panic("bad value")
	}
}

Output:

event, err := NewEvent("event", os.O_CREATE|os.O_EXCL, 0666, false)
if err != nil {
	return
}
go func() {
	event.Set()
}()
if event.WaitTimeout(time.Millisecond * 250) {
	// event has been set
} else {
	// timeout elapsed
}
event.Destroy()

Output:

DestroyMutex("mut")
mut, err := NewMutex("mut", os.O_CREATE|os.O_EXCL, 0666)
if err != nil {
	panic("new")
}
defer mut.Close()
var sharedValue uint64
var wg sync.WaitGroup
wg.Add(8)
for i := 0; i < 8; i++ {
	go func() {
		defer wg.Done()
		mut, err := NewMutex("mut", 0, 0)
		if err != nil {
			panic("new")
		}
		defer mut.Close()
		for i := 0; i < 1000000; i++ {
			mut.Lock()
			sharedValue++
			mut.Unlock()
		}
	}()
}
wg.Wait()
if sharedValue != 8*1000000 {
	panic("invalid value ")
}

Output:

const (
	writers = 4
	readers = 10
)
DestroyRWMutex("rw")
m, err := NewRWMutex("rw", os.O_CREATE|os.O_EXCL, 0666)
if err != nil {
	panic(err)
}
// we create a shared array of consistently increasing ints for reading and wriring.
sharedData := make([]int, 128)
for i := range sharedData {
	sharedData[i] = i
}
var wg sync.WaitGroup
wg.Add(writers + readers)
// writers will update the data.
for i := 0; i < writers; i++ {
	go func() {
		defer wg.Done()
		start := rand.Intn(1024)
		m.Lock()
		for i := range sharedData {
			sharedData[i] = i + start
		}
		m.Unlock()
	}()
}
// readers will check the data.
for i := 0; i < readers; i++ {
	go func() {
		defer wg.Done()
		m.RLock()
		for i := 1; i < len(sharedData); i++ {
			if sharedData[i] != sharedData[i-1]+1 {
				panic("bad data")
			}
		}
		m.RUnlock()
	}()
}
wg.Wait()
fmt.Println("done")

Output:

done

// create new semaphore with initial count set to 3.
DestroySemaphore("sema")
sema, err := NewSemaphore("sema", os.O_CREATE|os.O_EXCL, 0666, 3)
if err != nil {
	panic(err)
}
defer sema.Close()
// in the following cycle we consume three units of the resource and won't block.
for i := 0; i < 3; i++ {
	sema.Wait()
	fmt.Println("got one resource unit")
}
// the following two goroutines won't continue until we call Signal().
var wg sync.WaitGroup
wg.Add(2)
for i := 0; i < 2; i++ {
	go func() {
		defer wg.Done()
		// open existing semaphore
		sema, err := NewSemaphore("sema", 0, 0666, 0)
		if err != nil {
			panic(err)
		}
		defer sema.Close()
		sema.Wait()
		fmt.Println("got one resource unit after waiting")
	}()
}
// wake up goroutines
fmt.Println("waking up...")
sema.Signal(2)
wg.Wait()
fmt.Println("done")

Output:

got one resource unit
got one resource unit
got one resource unit
waking up...
got one resource unit after waiting
got one resource unit after waiting
done

DestroyMutex("mut")
mut, err := NewMutex("mut", os.O_CREATE|os.O_EXCL, 0666)
if err != nil {
	panic("new")
}
defer mut.Close()
tmut, ok := mut.(TimedIPCLocker)
if !ok {
	panic("not a timed locker")
}
var sharedValue int
rand.Seed(time.Now().Unix())
go func() {
	mut, err := NewMutex("mut", 0, 0)
	if err != nil {
		panic("new")
	}
	defer mut.Close()
	mut.Lock()
	// change value after [0..500] ms delay.
	time.Sleep(time.Duration(rand.Int()%6) * time.Millisecond * 100)
	sharedValue = 1
	mut.Unlock()
}()
// give another goroutine some time to lock the mutex.
time.Sleep(10 * time.Millisecond)
if tmut.LockTimeout(250 * time.Millisecond) {
	if sharedValue != 1 {
		panic("bad value")
	}
	tmut.Unlock()
} else {
} // timeout elapsed

Output: