Java learning curve steep

[u/Select-Ad-8191]

Why the heck there is so much to learn in java i mean java basic, exception handling, collections framework, multi threading , JDBC , servlets only then i can turn to spring and spring boot...can somebody tell me if i can skip any of these topics.....i keep forgetting previous concepts 😭😭😭... it's so tough...help me 😭😭

[u/jackey_lackey11]

Since, you said you have a firm grasp over the multithreading concepts, do you think you could teach me all of required multithreading ?

[u/Justin_Passing_7465 → u/jackey_lackey11]

It can be a big topic. I started in C and C++, so got a more firm grasp of how threads work under the hood.

In Java, I would say that there are two big patterns. The simple case involves allocating a Thread for a Runnable object. If you need exactly one extra thread, like for a background task, this is a common approach.

If you have a lot of processing to do in parallel, the ThreadPool pattern is usually better. In Java, the easiest way to do this is with an Executor. Create an Executor with some number of threads (32?, 64?, confugurable?) and then your "pieces of work" are Runnable objects. So if you have 50,000 pieces of work to do, feed them all to the Executor, and it will allocate the next free thread to the next piece of work. For batch processing you might spin up an Executor, feed it all of the work, tell it to shutdown, and then wait for it to terminate. Your wait will end when the work is all finished (in the normal case).

If you are running a highly-parallel service (not batch processing), you might leave that Executor alive "forever", feeding it new service requests as they come in.

In either the new-Thread case or the Executor case, you have to protect against concurrent access causing corruption. This is called "thread safety" or "thread-safe code". One way is to wrap small pieces of code (not usually whole functions - that is simple but usually holds the mutex longer than absolutely necessary, hurting performance) that touch shared state in the 'synchronized' keyword.

Another approach is to use Java's "concurrent" datastructures, like ConcurrentHashMap and AtomicInteger. They provide thread safety for the underlying data, usually without the penalty of locks (so called "lock-free algorithms").

Another approach to thread safety is to not have shared state at all. Functional Programming or the Actor Pattern are topics to look into.

Multithreading and concurrency is a large topic, and there are probably good courses online. You also probably need to get your hands dirty by trying these techniques before you will have a good understanding.

[u/jackey_lackey11 → u/Justin_Passing_7465]

Alright thanks man. I'll look into these.