go-concurrency | Go concurrency , goroutine and channel usage

Using a channel with buffer size 1, first write buffers data, then goroutines end and you can read the buffered data in the main goroutine.

When channel size is zero a write to the channel blocks until another goroutine reads from it. So both of your goroutines are waiting to write the channels. If you move the Wait() call after the channel reads in main it should work.

A few things here.

1. You have 2 goroutines, one running main(), and one running fibonacci(). Because this is a small program, there isn't a good reason for the go scheduler not to run them one after another on the same thread, so that's what happens consistently, though it isn't guaranteed. Because the goroutine in main() is waiting for the chan, the fibonacci() routine is scheduled first. It's important to remember that goroutines aren't threads, they're routines that the go scheduler runs on threads according to its liking.

2. Because you're passing the length of the buffered channel to fibonacci() there will almost certainly (never rely on this behavior) be cap(c) heres printed after which the channel is filled, the for loop finishes, a close is sent to the chan, and the goroutine finishes. Then the main() goroutine is scheduled and cap(c) fibonacci's will be printed. If the buffered chan had filled up, then main() would have been rescheduled: https://play.golang.org/p/_IgFIO1K-Dc

3. By sleeping you can tell the go scheduler to give up control. But in practice never do this. Restructure in some way or, if you must, use a Waitgroup. See: https://play.golang.org/p/Ln06-NYhQDj

4. I think you're trying to do this: https://play.golang.org/p/8Xo7iCJ8Gj6

If one of the channels is a timeout, odds of your work being done and the timeout firing at exactly the same time are so small they make no sense to consider.

The statement "... It chooses one at random if multiple are ready." is applicable when you actually have a viable reason for this to happen - when you have a select case on multiple job channels that you're processing with a single goroutine, for instance.

I have never used Django concurrency and I would run a mile if I run across apps that offer to abstract concurrency, transaction management etc. Based on general concepts of concurrency. This behaviour seems right. There's no error here.

django-concurrency is an optimistic lock [1] implementation for Django.

Supported Django versions: 1.8.x, 1.9.x, 1.10.x., 1.11.x

It prevents users from doing concurrent editing in Django both from UI and from a django command.

What this actually means is that two users cannot modify the same instance at the same time. In adhoc two browser testing of the sort that's just tried out, such a situation can never be produced! What usually happens is that one or the other transaction usually runs to completion because when testing on small databases on localhost, there is no latency and everything happens instantly.

The proper way to test this is to open up to separate change shells, open up the same instance and edit as outlined in the django concurrency guide. Or test with a multi threaded client.

And yes, I want to store the data at the settings.py.

No you definitely don't want to do that. the settings.py file is configuring django and any pluggable apps that you may use with it. it's not intended to be used as a place for dumping data. Data goes into a database.

And don't forget that the settings.py file is usually read only once.