thread_pool | c11 thread pool

As it seems noone else had the same issue or using primitive objects as cache entries, thus haven't noticed the issue. Upon replicating and fortunately traced the root cause, the below points are coming up :

• Always implement Serializable / hashCode / equals for custom objects that are going to end been transmitted through a replicated/synchronized cache.
• Never put primitive arrays, as the hashcode / equals would not be calculated - efficiently-
• Dont enable eviction with remove strategy on replicated caches, as upon reaching the maximum limit, the entries are getting removed randomly - based on TinyLFU - and not based on the expired timer and never getting removed from the JVM heap.

It looks like your route needs to match this pattern /auth/:provider/callback but doesn't. This is the route you should be accessing /auth/google_oauth2/callback, not /auth/google_oauth2

web-console gem was breaking with Rails 6.1, an upgrade to 4.1.0 fixed the error.

So... It seems this line in ActiveSupport v6.0.3.6 is calling this method in redis with 3 arguments instead of 2; exactly like the error says!

And just as I suspected, that's already been fixed in the master branch. Here was the commit that introduced the fix.

So in other words, I reckon you've found a bug in rails 6.0 working with ruby 3.0.

Additionally, it seems that this bug has already been backported into the 6.0-stable branch and, according to the comments, "will be included in Rails 6.0.4".

tl;dr: Either downgrade ruby back to 2.7, or upgrade rails to 6.1, or add to your Gemfile:

I was under the impression that only something that is sent via the channels must implement Send + Sync and I'm probably wrong here.

You are slightly wrong:

• A type is Send if its values can be sent across threads. Many types are Send, String is, for example.
• A type is Sync if references to its values can be accessed from multiple threads without incurring any data-race. Perhaps surprisingly this means that String is Sync -- by virtue of being immutable when shared -- and in general T is Sync for any &T that is Send.

Note that those rules do not care how values are sent or shared across threads, only that they are.

This is important here because the closure you use to start a thread is itself sent across threads: it is created on the "launcher" thread, and executed on the "launched" thread.

As a result, this closure must be Send, and this means that anything it captures must in turn be Send.

Why doesn't Rc implement Send?

Because its reference count is non-atomic.

That is, if you have:

• Thread A: one Rc.
• Thread B: one Rc (same pointee).

And then Thread A drops its handle at the same time Thread B creates a clone, you'd expect the count to be 2 (still) but due to non-atomic accesses it could be only 1 despite 2 handles still existing:

• Thread A reads count (2).
• Thread B reads count (2).
• Thread B writes incremented count (3).
• Thread A writes decremented count (1).

And then, the next time B drops a handle, the item is destructed and the memory released and any further access via the last handle will blow up in your face.

I've tried to synchronize the access (though it looks like useless as there is no shared variable in threads), but no luck:

You can't wrap a type to make it Send, it doesn't help because it doesn't change the fundamental properties.

The above race condition on Rc could happen even with a Rc wrapped in Arc<...>>.

And therefore !Send is contagious and "infects" any containing type.

Migrating to Arc is highly undesired due to performance issue and lot's of related code to be migrated to Arc too.

Arc itself has relatively little performance overhead, so it seems unlikely it would matter unless you keep cloning those Checker, which you could probably improve on -- passing references, instead of clones.

The higher overhead here will come from Mutex (or RwLock) if Checker is not Sync. As I mentioned, any immutable value is trivially Sync, so if you can refactor the internal state of Checker to be Sync, then you can avoid the Mutex entirely and just have Checker contain Arc.

If you have mutable state at the moment, consider extracting it, going towards:

Default headers can be configured in config/application.rb. Trying moving your code out of ApplicationController and into config/application.rb. That's where you'll have access to the config object.

If you need to set custom headers within the context of a controller, you can use response.headers.

There are several things that come to mind by seeing that you are not using the dev server, it's very likely to have an old version of your assets in public/packs.

Try removing that packs folder and run bin/server

shared_queue is default initialised therefore calling methods on it is undefined behaviour. Initialising it in the constructor of ThreadPool:

Erm, what is the code supposed to do anway?