Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

# Fork-join framework
There are new Java concurrency APIs (JSR 166y) referred to as the **Fork-join framework**. It is designed for tasks that can be broken down and takes advantage of multiple processors. The following are the core classes (all located in `java.util.concurrent`):
* `ForkJoinPool`: An ExecutorService for running ForkJoinTasks and managing and monitoring the tasks.
* `ForkJoinTask`: This represents the abstract task that runs within the ForkJoinPool.
* `RecursiveTask`: This is a subclass of ForkJoinTask whose compute method returns some value. 
* `RecursiveAction`: This is a subclass of ForkJoinTask whose compute method does not return any value.

# Examples


As an example of using this framework, let’s find the sum of 2,000 integers. This is a trivial example but will hopefully demonstrate proper use of the ForkJoin framework.

In this example, we will divide the array of integers in half and assign each half to a `RecursiveTask`. If the array size is less than 20 elements, we assign it to another `RecursiveTask` that computes the sum of the array.

Here is the `RecursiveTask` for computing the sum:

```
package com.adamldavis.java.forkjoin;
import java.util.concurrent.RecursiveTask;

class SumCalculatorTask extends RecursiveTask<Integer>{
	int [] numbers;
	SumCalculatorTask(int[] numbers){
		this.numbers = numbers;
	}
	
	@Override
	protected Integer compute() {
		int sum = 0;
		for (int i : numbers){
			sum += i;
		}
		return sum;
	}
}
```
The compute method has to be overridden with the actual task to be performed. In the above case, it iterates through the elements of the array and returns the computed sum.

We create a `RecursiveTask` for dividing the array into two parts and assign each part to another `RecursiveTask` for further dividing. We continue dividing the array and stop dividing when the array has less than 20 elements.

```
package com.adamldavis.java.forkjoin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.RecursiveTask;

class NumberDividerTask extends RecursiveTask<Integer> {
	int[] numbers;

	NumberDividerTask(int[] numbers) {
		this.numbers = numbers;
	}

	@Override
	protected Integer compute() {
		int sum = 0;
		List<RecursiveTask<Integer>> forks = new ArrayList<>();
		if (numbers.length > 20) {
			NumberDividerTask task1 = new NumberDividerTask(Arrays.copyOfRange(
					numbers, 0, numbers.length / 2));
			NumberDividerTask task2 = new NumberDividerTask(Arrays.copyOfRange(
					numbers, numbers.length / 2, numbers.length));
			forks.add(task1);
			forks.add(task2);
			task1.fork();
			task2.fork();
		} else {
			SumCalculatorTask sumCalculatorTask = new SumCalculatorTask(numbers);
			forks.add(sumCalculatorTask);
			sumCalculatorTask.fork();
		}
		// Combine the result from all the tasks
		for (RecursiveTask<Integer> task : forks) {
			sum += task.join();
		}
		return sum;
	}
}
```
The above `NumberDividerTask` spawns either two other `NumberDividerTask’s` or a `SumCalculatorTask`. Each task keeps track of the sub-tasks it has created. At the end of the task, we wait for all the tasks in the forks list to finish by invoking the `join()` method and compute the sum of those values returned from the sub-tasks.

To invoke the above-defined tasks, we use ForkJoinPool and create a `NumberDividerTask` task by giving it the array whose sum we wish to compute.

```
package com.adamldavis.java.forkjoin;
import java.util.concurrent.ForkJoinPool;

public class ForkJoinTest {
	static ForkJoinPool forkJoinPool = new ForkJoinPool();
	public static final int LENGTH = 2000;
	
	public static void main(String[] args) {
		int [] numbers = new int[LENGTH];
		// Create  an array with some values. 
		for(int i=0; i<LENGTH; i++){
			numbers[i] = i * 2;
		}
		int sum = forkJoinPool.invoke(new NumberDividerTask(numbers));
	  
		System.out.println("Sum: "+sum);
	}
}
```
After running the above code, the output should be: "Sum: 3998000".

Let's check this below.





Fork/Join

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Fork/Join

Fork-join framework