Synchron | A karaoke app in virtual reality | Runtime Evironment library

Additional synchronization would not be necessary in this case for at least 2 reasons.

1. cudaMemcpy is a synchronizing call already. It blocks the CPU thread and waits until all previous CUDA activity issued to that device is complete, before it allows the data transfer to begin. Once the data transfer is complete, the CPU thread is allowed to proceed.

2. CUDA activity issued to a single device will not overlap in any way unless using CUDA streams. You are not using streams. Therefore even asynchronous work issued to the device will execute in issue order. Item A and B issued to the device in that order will not overlap with each other. Item A will complete before item B is allowed to begin. This is a principal CUDA streams semantic point.

According to the Go memory model:

https://golang.org/ref/mem

There are no guarantees that one goroutine will see the operations performed by another goroutine unless there is an explicit synchronization between the two using channels, mutex. etc.

In your example: the fact that a goroutines sees done=true does not imply it will see a set. This is only guaranteed if there is explicit synchronization between the goroutines.

The sync.Once probably offers such synchronization, so that's why you have not observed this behavior. There is still a memory race, and on a different platform with a different implementation of sync.Once, things may change.

First make a Repository class and make an instance of your DAO

If your functions are declared async, you need to use the await keyword when calling them. And consequently you need to declare the Cloud Function itself as async.

So the following should do the trick:

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

I'm the author of the article you referenced.

As discussed in Discover concurrency in SwiftUI, views can make use of the new .task { } and .refreshable { } modifiers to fetch data asynchronously.

So you now have the following options to call you async code:

MainCoroutineRule and runBlocking are seemingly similar but there are clear differences.

Defenition of MainCoroutineRule:

MainCoroutineRule installs a TestCoroutineDispatcher for Disptachers.Main. Since it extends TestCoroutineScope, you can directly launch coroutines on the MainCoroutineRule as a [CoroutineScope]...

Defenition of runBlocking:

Runs a new coroutine and blocks the current thread interruptibly until its completion. This function should not be used from a coroutine. It is designed to bridge regular blocking code to libraries that are written in suspending style, to be used in main functions and in tests. ...

In terms of definition, runBlocking is used for the sole purpose of synchronous execution in coroutines. It is not only used in tests but also used in UI management, Data Management, and several other areas in Android Development.

Whereas runBlocking is used more generally, MainCoroutineRule is used only in tests and it has the same synchronous execution behavior found in runBlocking. However, MainCoroutineRule has more specialized testing features not found in runBlocking such as control flow management. In addition, using MainCoroutineRule will significantly make your testing code cleaner.

In a much more detailed manner, MainCoroutineRule is directly related to JUnit Rule. If you have used JUnit before, you might remember filling out @Before @After to provide a testing environment for the test cases. If you have multiple test cases, you would eventually have to write multiple @Before @After to provide multiple testing environments, which could possibly lead to redundant boilerplate code. Now, this is where MainCoroutineRule shines! With MainCoroutineRule you can declare a testing environment once and reuse them for multiple test cases.

Compare two sample codes below:

Test case without using MainCoroutineRule

One idea could be to return the Job in method1 like the following:

Collections.shuffle() Randomly permutes the specified list using a default source of randomness. All permutations occur with approximately equal likelihood.

So if tasks ar shuffled, sometimes task2 run first and then output is different.