Scribd
Upload
2 views

# ArraySum.java

The document describes the implementation of an ArraySum class using the Fork-Join model for parallel computation. It details the SumTask class that recursively divides an array into smaller subtasks to calculate the sum, leveraging a ForkJoinPool for efficient task execution. Additionally, it explains the advantages of using a thread pool for task management over creating new threads for each task.

Uploaded by

hoangtu112201
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
2 views

# ArraySum.java

The document describes the implementation of an ArraySum class using the Fork-Join model for parallel computation. It details the SumTask class that recursively divides an array into smaller subtasks to calculate the sum, leveraging a ForkJoinPool for efficient task execution. Additionally, it explains the advantages of using a thread pool for task management over creating new threads for each task.

Uploaded by

hoangtu112201
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 2

# ArraySum.

java

Fork-Join Model: based on divide-and-conquer


fork: recursively break a task into smaller subtasks until they are simple enough
to run asynchronously.
join: solve each subtask and combine the results recursively

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ArraySum {


private static class SumTask extends RecursiveTask<Long> {
private final int[] array;
private final int start, end;
private static final int THRESHOLD = 1000;

public SumTask(int[] array, int start, int end) {


this.array = array;
this.start = start;
this.end = end;
}

@Override
protected Long compute() {
int length = end - start;
if (length <= THRESHOLD) {
// Compute directly
long sum = 0;
for (int i = start; i < end; i++) {
sum += array[i];
}
return sum;
} else {
// Split task
int mid = start + length / 2;
SumTask leftTask = new SumTask(array, start, mid);
SumTask rightTask = new SumTask(array, mid, end);

// Fork subtasks
leftTask.fork();
rightTask.fork();
long rightResult = rightTask.join();
long leftResult = leftTask.join();

return leftResult + rightResult;


}
}
}

public static void main(String[] args) {


// Sample array
int[] array = new int[10_000];
for (int i = 0; i < array.length; i++) {
array[i] = i + 1;
}

ForkJoinPool pool = new ForkJoinPool();


SumTask task = new SumTask(array, 0, array.length);
long result = pool.invoke(task);
System.out.println("Sum of array elements: " + result);
}
}
- a special thread pool designed to work well with fork-join model.
- executes subtasks in parallel using a pool (fixed number) of worker threads.
- It uses a work-stealing algorithm, where idle threads "steal" tasks from busy
threads to improve efficiency.
- Often more efficient than manually creating threads for recursive tasks.
Thread Pool
- a pool of threads that can be reused to execute tasks, so that each thread may
execute more than one task.
- comparison: "creating a new thread per task" vs. "thread pool reusing existing
threads for task execution"
+ Creating a new thread comes with a performance overhead compared to reusing a
thread that is already created.
+ That is why reusing an existing thread to execute a task can result in a higher
total throughput than creating a new thread per task.
+ Thread pool makes it easy to control how many threads are active at a time.
+ Built-in thread pool: ExecutorService

You might also like