interlock | Docker Event Driven Plugin System | Continuous Deployment library

The runtime is allowed to move memory access for optimization. If there is a lock, the memory access may not be moved before entering or after leaving the lock. See also this blog post by Eric Lippert:

The C# compiler, JIT compiler and CPU are all permitted to make optimizations provided that the optimization is undetectable by the current thread. In particular, reads and writes of variables may be re-ordered or eliminated entirely provided that doing so is not observable to the current thread. [...] A lock introduces a restriction on these optimizations. In particular: no read may be moved before the beginning of a lock statement, and no write may be moved after the end of a lock statement.

Hence for example in your ToggleBar method, you can be sure that the bar variable is read after the method is entered and it has been written when the method is left. In your ReadBar method, you can be sure that the bar is read every time when the method is called.

PowerShell will natively parse a valid hexadecimal numeral when you convert a string to an integral type:

The asynchronous API Parallel.ForEachAsync does not offer the Stop/Break functionality of its synchronous counterpart.

One way to replicate this functionality is to use a bool flag in combination with the TakeWhile LINQ operator:

Ultimately this really depends on how your customer segmentation info is stored. Let's assume it's in dictionary form. Then you can use the itertools.product function to get everything you want but you also need to do a bit of preprocessing and some postprocessing to store it all in the html in the desired form. If you have a template library that will do this for you (your web framework may have something that is preferable. Ultimately this really depends on how you want to use the output. Here's one way:

No, you cannot remove the call to Volatile.Write.

You are correct in regards the atomicity point: C# and the CLR mandates that 32-bit and smaller data types shall be atomic.

However, there is not just atomicity to consider. There is also instruction reordering and processor caching to consider.

Reordering may happen by the CLR Jitter, and the size of your function is not relevant, as it may be inlined into any function which calls it (and probably will be given it's short).

The processor also may reorder instructions, if it conforms to the instructions it has been given.

So this needs a memory barrier to be thread-safe.

Processor caching is another issue: if the processor core is not told that a read or write is volatile, it could just use its own cache and ignore an what is in other cores' caches.

But, Volatile.Write may not be enough anyway. I can't tell exactly from what you have shown, but it seems you have multiple threads which read and write. I think you should therefore use Interlocked.Exchange instead.

azure app service

This is almost certainly due to multiple instances of your app running.

What would be the safest way to have the backgroundservice running only once, beside going through some data persist / check in DB?

An external "lease" is the safest approach. You can build one yourself using CosmosDb / Redis as a backend, or you can use a built-in approach by factoring your background service out of your web app into either an Azure WebJob or an Azure Function. Both of those services use leases automatically for timer-triggered jobs.

I have finally made it work somehow, No I have not unistalled it or re-installed it. It is as of now working fine, the process is given below:

1. Went to C:\xampp_php8\mysql , my xampp mysql's root folder:
2. Renamed data folder to data_blah blah...
3. Created new data folder, copied and pasted all contents of backup folder in this data folder
4. Started xampp, apache, mysql, went https://localhost/phpmyadmin, everything works fine here.
5. Stopped xampp, copied only the database folders I needed & ib_logfile0,ib_logfile1 and ibdata1 from old data directory and pasted in the new data directory.
6. Started xampp, apache, mysql, everything seemed fine but INSERT privileges were missing.
7. Lastly, pressed Empty session data in https://localhost/phpmyadmin/index.php.

And now everything works fine.

Correct me if I'm wrong here, but the above code does ensure that I'm achieving the goal of getting the latest value of Options when I get it in a thread safe manner? Any other issues using this method?

Yes, locks will emit memory barriers, so it will ensure the value is read from memory. There are no real issues other than potentially being more conservative than it has to be. But I have a saying, if in doubt, use a lock.

I believe there is some overhead with the lock (Converts to Monitor.Enter/Exit). I thought I could use Interlocked for a nominal performance gain, but more importantly to me, a cleaner set of code. Would the following work to achieve synchronization?

Interlocked should also emit memory barriers, so I would think this should do more or less the same thing.

Since a reference assignment is atomic, is the synchronization (using either lock or Interlocked) necessary when assigning the reference? If I omit the set logic and only maintain the get, will I still maintain atomicity and synchronization? My hopeful thinking is that the lock/Interlock usage in the get would provide the synchronization I'm looking for. I've tried writing sample programs to force stale value scenarios, but I couldn't get it done reliably.

I would think that just making the field volatile should be sufficient in this scenario. As far as I understand it the problem with "stale values" is somewhat exaggerated, the cache coherency protocols should take care of most issues.

To my knowledge, the main problem is preventing the compiler from just put the value in a register and not do any subsequent load at all. And that volatile should prevent this, forcing the compiler to issue a load each time it is read. But this would mostly be an issue when repeatedly checking a value in a loop.

But it is not very useful to look at just a single property. Problems more often crop up when you have multiple values that needs to be synchronized. A potential issue is reordering instructions by the compiler or processor. Locks & memory barriers prevent such reordering, but if that is a potential issue, it is probably better to lock a larger section of code.

Overall I consider it prudent to be paranoid when dealing with multiple threads. It is probably better to use to much synchronization than to little. One exception would be deadlocks that may be caused by having too many locks. My recommendation regarding this is to be very careful what you are calling when holding a lock. Ideally a lock should only be held for a short, predictable, time.

Also keep using pure functions and immutable data structures. These are a great way to avoid worrying about threading issues.

It seems that your tests do not generate usable info for proving or disproving the correct order of execution. The Thread.CurrentThread.ManagedThreadId is just an ID, and not a reliable indication of order. Also writing in the Console while the program is running may affect the order of execution, because all access to the static Console class is synchronized.

The test below uses the custom QueuedLock class (modified) to ensure the order of execution, and reports FIFO behavior consistently. I've added a Thread.Sleep(20) before starting each thread, to avoid having two threads requesting a ticket at roughly the same time. There is also a Thread.Sleep(40) inside the ThreadStart delegate, to ensure that all threads will get blocked before entering the QueuedLock (apart from the first thread of each batch).