If any OS is multi-processor, then JVM uses all of them or one of them? On most modern hardware architectures, the JVM will make use of all CPUs/cores made available to it by the OS. And As processors ahve different memory context so their corresponding memory threads will also have different memory contexts, so they … Read more
As you can tell from some of the comments, multithreaded code is serious business. It’s best to follow a proven pattern, e.g. producer-consumer, or at least use an established synchronization primitive like a monitor or semaphore. Because I might be wrong. It is easy to go over code that you came up with yourself and … Read more
Exactly same time is not possible. Java Virtual Machines often use the underlying scheduler provided by the OS kernel. Scheduler implements a function s(t) from time to processes that assigns the CPU to a process according to a specific policy (FIFO, SJF, Round Robin, Real Time policies, and so on). In each t, only one … Read more
Use transactions. Each transaction is ensuring the consistency of the data (quantity >= 0) at the end of the transaction. Consistency should be checked exclusively, so no two transactions are allowed to modify quantity at the same time. OR Do what amazon does – accept the order (no commitment), no modifying of the quantity. Next … Read more
However, in some cases I am just interested in the latest value of a variable or field of an object. Here is the fundamental problem: What does the word “latest” mean? Suppoose that, mathematically speaking, we have a sequence of values Xi, with 0 <= i < N. Then obviously Xj is “later than” Xi … Read more
It strikes me that there is a much simpler solution that doesn’t involve explicit semaphores and custom code (and bugs). Just use a bounded BlockingQueue (javadoc) and have the threads use put(…) to add items to the queue. When queue is full, put will block the thread that is calling it … until queue space … Read more
Yes Threads would be executing the same piece of code but if your code contains shared class level variables then it needs to be properly synchronised so that the each thread reads a consistent state of variables. Threading is to ensure concurrent access to a piece of code via multiple threads. There are different ways … Read more
this just isn’t how you’re supposed to work with threads. You have 2 major problems here: java memory model. Imagine that one thread writes to some variable, and a fraction of a second later, another thread reads it. If that would be guaranteed to work the way you want it to, that means that write … Read more
For synchronizing a HashMap,you can use Collections.synchronizedMap(<your hashmap reference>) which will return a synchronized map for you, which is thread-safe. solved How to change HashMap as Synchoronized
Consider a worker pool pattern like this: https://go.dev/play/p/p6SErj3L6Yc In this example application, I’ve taken out the API call and just list the file names. That makes it work on the playground. A fixed number of worker goroutines are started. We’ll use a channel to distribute their work and we’ll close the channel to communicate the … Read more
The Java garbage collector (GC) reclaims objects that are not traceable starting from a set of GC roots. That is, if object A is referenced by object B, and object B is referenced by object C, and object C is referenced by a root, then objects A, B, and C are all safe from the … Read more
The select statement chooses a case whose communication op would not block. If there are multiple cases whose comm. op would not block, one is chosen randomly. Since in the example all communication ops would block, and since a default is provided, that will be executed. To “trigger” another case, you have to make sure … Read more
If you need such sequencing, you might reevaluate your need to use goroutines. However, the way you described the solution is correct: go first() { for { <-ch1 // do stuff ch2<-struct{}{} } }() go second() { for { <-ch2 // do stuff ch3<-struct{}{} } }() go third() { for { <-ch3 // do stuff … Read more
Your code needs to wait for the routines to finish before exiting. A good way to do this is to pass in a channel which is used by the routine to signal when it’s done and then wait in the main code. See below. Another advantage of this approach is that it allows/encourages you to … Read more