threadpool | Parallel Processing in R using a Thread Pool | Architecture library

For one application instance running on tomcat, tomcat will have one threadpool created when the server starts, the application will have the fixed threadpool created on startup. This is not a shared nothing cgi, it's a single long running java process that stays in memory, 200 + 10 is right.

If you create a pool within a method call then each method call would allocate its own pool. So if every thread in tomcats pool was concurrently making a request that called a method that created its own pool then the number of threads in use could be up to the tomcat pool size times the method pool size.

Generally I would recommend not doing this because it would seem to undercut two advantages of using a pool: 1) that you can preallocate threads so your code doesn't have to wait on thread creation, and 2) that you can put an upper bound on the maximum number of threads your program uses.

Looks like Grizzly is trying to obtain the hostname from the Host header in the request. Since HTTP 1.1 the Host header is required but if the Host header is set an empty name, Grizzly cannot obtain the name and throws an exception.

The Host request header is set by the HTTP client. But even if the Host header exists but its value is empty due to some reason the exception will be thrown.

Grizzly Code: the code that throws the Exception

According to the Javadocs for Grizzly you can set the default hostname by calling the setDefaultHostName(String defaultHostName) method, but the instance of the Mapper in the HttpHanderChain instance is not exposed. The default value set in HttpHanderChain of the Mapper instance is set to "localhost".

OkHttp limits its own resource usage limits, but not here. Instead, Dispatcher limits how many calls are in flight concurrently, and ConnectionPool limits how many connections are alive.

This is my general idea:

Since memory is a problem, you have to read the files in smaller chunks, say 64K pieces and encrypt each 64K block and write those out. Of course, the encrypted block will have a length other than 64K so the problem becomes how to decrypt. So each encrypted block must be prefixed with a fixed-length header that is nothing more than the length of the following encrypted block encoded as a 4-byte unsigned integer (which should be way more than adequate). The decryption algorithm loop first reads the next 4-byte length and then know from that how many bytes long is the encrypted block that follows.

By the way, there is no need to pass to encfile a lock if you are not using it to, for example, count files processed.

The fact that you get an IndexError when accessing td_tags implies that len(td_tags) is not always 6 or 7. It is <6 at least once.

Look at this bit of code:

Regarding your edited question, yes busy spinning will give you the lowest latency of communication between the threads but you will pay for it by burning CPU time.

On the other hand you can use SpinWait which is less aggressive or you can code something in between such as this.

It comes down to a trade-off on how much you value latency and how many cores you have to spare.

It seems you are running different node version in your githubAction.

Set up the same node version that you use local(e.g. 14) before to run npm ci:

It’s setTimeout. There is considerable indirection between that and QueueUserWorkItem, but this is where it bottoms out.

Most of the WebAssembly-specific machinery can be seen in PR 38029. The WebAssembly implementation of RequestWorkerThread calls a private method named QueueCallback, which is implemented in C code as mono_wasm_queue_tp_cb. This in invokes mono_threads_schedule_background_job, which in turn calls schedule_background_exec, which is implemented in TypeScript as:

In a correctly implemented async implementation: there is no wait. Instead, at the bottom of the chain, some code exists that will create some async source, which could be a TaskCompletionSource, an IValueTaskSource[], or something similar - which allows that code to store that token somewhere (for example, in a queue, a correlation dictionary, or an async state object for IOCP), and return the incomplete task to the caller. The caller then discovers that it is incomplete, and registers a "when you have the answer, do this to reactivate me" callback. That calling code now unwinds completely, with every step saying "when you're done, push here", and the thread goes on to do other things, such as service a different request.

At some point in the future (hopefully), the result will come back - again, via IOCP, or via a separate IO reader pulling a response from somewhere and taking the appropriate item out of the queue/correlation-dictionary, and says "the outcome was {...}" (TrySetResult, TrySetException, etc).

For all of that time no threads were blocked. That is, ultimately, the entire point of async/await: to free up threads, to increase scalability.

In incorrectly implemented async systems: anything and everything is possible, including async-over-sync, sync-over-async, and everything else.