An example of the modifications needed to parallelize something (using futures) in Java and Scala (check the diff).

Operations.java

package tests.javafuture;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Operations {
	private final int cores = Runtime.getRuntime().availableProcessors();
	private final ExecutorService pool = Executors.newFixedThreadPool(this.cores);

	public int operations (int number) {
		Future<Integer> futureNumber = this.pool.submit(new Operation1Runner(number));
		int number1 = 1;
		int number2 = this.operation2(number);
		try {
			number1 = futureNumber.get();
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
		return number1 * number2;
	}

	private int operation1 (int number) {
		return 1 + number;
	}

	private int operation2 (int number) {
		return 2 + number;
	}

	private class Operation1Runner implements Callable<Integer> {

		private int number;

		public Operation1Runner(int number) {
			this.number = number;
		}

		@Override
		public Integer call () throws Exception {
			return ParallelOperations.this.operation1(this.number);
		}
	}

}

Operations.scala

package test.scalafuture

import scala.concurrent._
import ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration._

class Operations {
    
    def operations(number: Int): Int = {
        val op1 = future { operation1(number) }
        operation2(number) * Await.result(op1, Inf)
    }
    
    private def operation1(number: Int): Int = number + 1
    private def operation2(number: Int): Int = number + 2
}