Locks | source code for Locks , a small , but unique Minecraft mod

I got the following table to populate (range D6:J15) as I search the data in another sheet, based on a date criteria found in row 4:

This is where I'm to look for the data, considering Col A as the basis for the criteria:

My difficulty is to concatenate the data, as they meet the criteria.

This is the code I'm working on:

I wanted to update the entire row with new submitted data based on ID. I have a form on my page that sends the data to my sheet using Javascript.

Here's the simple script that sends based on input ID:

I have been trying to install Angular but everytime this part:

@angular/cli@12.0.3 postinstall C:\Users\Marco\AppData\Roaming\npm\node_modules@angular\cli

node ./bin/postinstall/script.js

Seems to throw an error. I'm not sure if I need this to work or not so I'll leave the last couple lines of the log here.

Is there a proven programmatic way to achieve mutual exclusion of multiple Mutexes / Locks / whatever in Golang? Eg.

I am writing a small TCP sockets "library", and I ran into much trouble.

When something happens to the socket that causes it to be instantly closed and freed (regardless of background lingering, talking about user space here), which is only done within a locked mutex since the application I'm writing is multi-threaded, I need a way to tell all the other (potentially) waiting threads (on the same mutex) that want to do something with the socket: "I'm terribly sorry, but the socket has been destroyed and you cannot access it" so that they don't cause any segmentation fault or such.

The idea I had was: the mutex was part of the socket (socket = a structure that contains multiple things, including a mutex and a file descriptor) so I couldn't quite free the socket if other threads were waiting for it (undefined behavior), so the possible solution is to allocate the mutex, free the socket but not the mutex, set some flag (in the allocated memory) saying that the socket has been closed, and a counter so that the last thread waking up and getting notified that it cannot use the socket unlocks and destroys the mutex and frees the memory allocated. The mutex can still be accessed without segfault if we just store its pointer before acquiring the mutex (and the pointer won't ever change).

This solution has a fundamental problem though - what if between unlocking the mutex and freeing it by the last holder, the thread gets preempted and another one locks the mutex again (since you NEED to check socket-related stuff after you acquire the lock, so no way of knowing it got destroyed, unless you maybe use an atomic variable but then again, checking the atomic variable and locking the mutex as a whole are not an atomic operation). Or if you try to access the mutex on the already-freed socket. Undefined behavior emerges.

Any ideas how to solve this problem? I.e. how to destroy a socket so that other threads know about it to quit safely, and there are no race conditions? By quitting I mean aborting the socket function they were in, not cancelling or stopping the threads themselves.

I have a capsule object with Camera on it. Capsule has capsule collider with mesh, character controller. cylinder object (coin) is box collider with is trigger option being on. OnTriggerObject method doesn't help to destoy the coin object. Even used OnCollisionEnter, eventually have the same result. Also tried with rigidbody added to the player object and removed from coin object. Even don't remember what I tried on. Here is script attached to capsule object:

I am using C#, TPL. I have a class that contains some asynchronous methods that execute some sub-tasks, for simplicity I will only consider one method and one sub-task:

I'm trying to find an alternative to using the Restart Manager for checking if a file is locked. I found this accepted answer to the same question. However, the accepted answer contains the following comment that I do not understand: "this solution will not work if the file doesn't have a Write or Read lock on it, i.e. it has been opened (for reading or writing) with FileShare.Read or FileShare.Write access."

I tested this using the following code (ommitted using blocks and Close() for brevity):

I have a relatively simple case where:

1. My program will be receiving updates via Websockets, and will be using these updates to update it's local state. These updates will be very small (usually < 1-1000 bytes JSON so < 1ms to de-serialize) but will be very frequent (up to ~1000/s).
2. At the same time, the program will be reading/evaluating from this local state and outputs its results.
3. Both of these tasks should run in parallel and will run for the duration for the program, i.e. never stop.
4. Local state size is relatively small, so memory usage isn't a big concern.

The tricky part is that updates need to happen "atomically", so that it does not read from a local state that has for example, written only half of an update. The state is not constrained to using primitives and could contain arbitrary classes AFAICT atm, so I cannot solve it by something simple like using Interlocked atomic operations. I plan on running each task on its own thread, so a total of two threads in this case.

To achieve this goal I thought to use a double buffer technique, where:

1. It keeps two copies of the state so one can be read from while the other is being written to.
2. The threads could communicate which copy they are using by using a lock. i.e. Writer thread locks copy when writing to it; reader thread requests access to lock after it's done with current copy; writer thread sees that reader thread is using it so it switches to other copy.
3. Writing thread keeps track of state updates it's done on the current copy so when it switches to the other copy it can "catch up".

That's the general gist of the idea, but the actual implementation will be a bit different of course.

I've tried to lookup whether this is a common solution but couldn't really find much info, so it's got me wondering things like:

1. Is it viable, or am I missing something?
2. Is there a better approach?
3. Is it a common solution? If so what's it commonly referred to as?
4. (bonus) Is there a good resource I could read up on for topics related to this?

Pretty much I feel I've run into a dead-end where I cannot find (because I don't know what to search for) much more resources and info to see if this approach is "good". I plan on writing this in .NET C#, but I assume the techniques and solutions could translate to any language. All insights appreciated.