1

What I know is after JDK 1.2 all Java Threads are created using 'Native Thread Model' which associates each Java Thread with an OS thread with the help of JNI and OS Thread library.

So from the following text I believe that all Java threads created nowadays can realize use of multi-core processors:

Multiple native threads can coexist. Therefore it is also called many-to-many model. Such characteristic of this model allows it to take complete advantage of multi-core processors and execute threads on separate individual cores concurrently.

But when I read about the introduction of Fork/Join Framework introduced in JDK 7 in JAVA The Compelete Reference :

Although the original concurrent API was impressive in its own right, it was significantly expanded by JDK 7. The most important addition was the Fork/Join Framework. The Fork/Join Framework facilitates the creation of programs that make use of multiple processors (such as those found in multicore systems). Thus, it streamlines the development of programs in which two or more pieces execute with true simultaneity (that is, true parallel execution), not just time-slicing.

It makes me question why the framework was introduced when 'Java Native Thread Model' existed since JDK 3?

Botje
  • 26,269
  • 3
  • 31
  • 41
Ankit Chauhan
  • 646
  • 6
  • 20

1 Answers1

3

Fork join framework does not replace the original low level thread API; it makes it easier to use for certain classes of problems.

The original, low-level thread API works: you can use all the CPUs and all the cores on the CPUs installed on the system. If you ever try to actually write multithreaded applications, you'll quickly realize that it is hard.

The low level thread API works well for problems where threads are largely independent, and don't have to share information between each other - in other words, embarrassingly parallel problems. Many problems however are not like this. With the low level API, it is very difficult to implement complex algorithms in a way that is safe (produces correct results and does not have unwanted effects like dead lock) and efficient (does not waste system resources).

The Java fork/join framework, an implementation on the fork/join model, was created as a high level mechanism to make it easier to apply parallel computing for divide and conquer algorithms.

Joni
  • 108,737
  • 14
  • 143
  • 193
  • 3
    It's probably also worth mentioning that even if one programmer is perfect in writting multi-threaded code using the original (low-level) Thread API, code maintainers who will follow are very likely to introduce subtle bugs into the exisitng multi-threaded code when the need for change arises. Having _better abstractions_ like fork/join (and others) helps to ensure that multi-threaded code is written correctly the first time, and then remains correct when others need to maintain it for years to come. – Ivo Mori Jul 19 '20 at 15:16