# Trivial concurrency exercises

I have been working on concurrency exercises and I can not get my head around them. This problem is supposed to be for the confused newbie Gopher but it seems very advance. Could someone solve this problem and give me a lift on how to approach algorithms in Golang with concurrency? Thanks

###Exercise 1: The Daily Walk
Every morning, Alice and Bob go for a walk, and being creatures of habit, they follow the same routine every day.
First, they both prepare, grabbing sunglasses, perhaps a belt, closing open windows, turning off ceiling fans, and pocketing their phones and keys.
Once theyâ€™re both ready, which typically takes each of them between 60 and 90 seconds, they arm the alarm, which has a 60 second delay.
While the alarm is counting down, they both put on their shoes, a process which tends to take each of them between 35 and 45 seconds.
Then they leave the house together and lock the door, before the alarm has finished its countdown.
Write a program to simulate Alice and Bobâ€™s morning routine.
####sample output
Letâ€™s go for a walk!
Alice spent 72 seconds getting ready
Bob spent 76 seconds getting ready
Arming alarm.
Bob started putting on shoes
Alarm is counting down.
Alice started putting on shoes
Alice spent 37 seconds putting on shoes
Bob spent 39 seconds putting on shoes
Exiting and locking the door.
Alarm is armed.

This is just a quick and rough solution, but it creates the same output and should get the idea across assuming you can find your way through my messy code^^

http://play.golang.org/p/JJcPhUNBzJ

IMO the most important idea (coming from â€śsimplerâ€ť languages like JS, PHP etc, I donâ€™t know anything about â€śtraditionalâ€ť multithreading) is when you block and when you donâ€™t.

• When you call a function (â€śtraditionallyâ€ť), you block, ie you wait for it to finish and then move along.
• When you call go aFunction() you donâ€™t wait for it to finish, basically saying â€śyou go ahead and do your thingâ€ť, meanwhile breezing along.

In your example you then need to â€śsyncâ€ť them, ie wait till everyone is finished. My solution is probably not the most elegant one, but the idea is that when you receive from a channel, you block until you get an answer. (I just wait for either one of them to respond and then wait for the other one)

All the above is assuming you know a little about go, functions, channels etc; if not, please ask and specify
There are probably loads of good writings on this, I can recommend this one, itâ€™s a very quick read.

2 Likes

Your code will get me off the ground. It is better than mines. The sync part is what I had trouble understanding. Also how to code the timer part. Thanks alot.

Quick one with sync.WaitGroup http://play.golang.org/p/OzqSLtR-I4

This implementation is very close to what I did the first time. Then I decided to change it a bit and came up with this solution

Iâ€™m open to suggestions.

Somethings I learned:

• `Time.UnixNano()` is great for precision
• You can re-use the same instance of `sync.WaitGroup` as long as you keep adding â€śthings to waitâ€ť and calling `Done()` the right amount of times.

This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.