Scribd
Upload
8 views3 pages

Parallel Array Sum with Threads

The document presents a Java program that implements a multi-threaded approach to calculate the sum of an array using multiple threads. It defines a `SumTask` class for computing partial sums and a `DistributedSum` class to manage the creation and execution of these threads. The program initializes an array, divides the work among threads, and aggregates the results to produce a final sum output.

Uploaded by

shindesamiksha685
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
8 views3 pages

Parallel Array Sum with Threads

The document presents a Java program that implements a multi-threaded approach to calculate the sum of an array using multiple threads. It defines a `SumTask` class for computing partial sums and a `DistributedSum` class to manage the creation and execution of these threads. The program initializes an array, divides the work among threads, and aggregates the results to produce a final sum output.

Uploaded by

shindesamiksha685
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

public class SumTask extends Thread {

private int[] array;

private int start, end;

private int partialSum;

// Constructor to initialize the array and the range (start, end) for the sum

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

[Link] = array;

[Link] = start;

[Link] = end;

[Link] = 0;
}

// Run method to compute the sum for the given range

@Override

public void run() {

for (int i = start; i < end; i++) {

partialSum += array[i];

}
[Link]("Partial sum from processor (thread): " + partialSum);

// Getter for the partial sum

public int getPartialSum() {

return partialSum;

}
}

1
DS 3 code
public class DistributedSum {

public static void main(String[] args) {

int N = 1000; // Size of the array (can be adjusted)


int n = 4; // Number of processors (threads)

// Create an array of N elements

int[] array = new int[N];

for (int i = 0; i < N; i++) {

array[i] = i + 1; // Initialize the array with values 1, 2, ..., N

// Calculate the size of each chunk (each processor handles N/n elements)

int chunkSize = N / n;

// Create an array of threads to compute the sum

SumTask[] tasks = new SumTask[n];

for (int i = 0; i < n; i++) {

int start = i * chunkSize;


int end = (i == n - 1) ? N : (i + 1) * chunkSize; // Make sure the last thread processes
any remaining elements
tasks[i] = new SumTask(array, start, end);

// Start all the threads

for (int i = 0; i < n; i++) {

tasks[i].start();

2
DS 3 code
// Wait for all threads to finish

int totalSum = 0;

for (int i = 0; i < n; i++) {

try {
tasks[i].join(); // Wait for the thread to finish

totalSum += tasks[i].getPartialSum(); // Aggregate partial sum

} catch (InterruptedException e) {

[Link]("Thread interrupted: " + e);

// Output the final sum


[Link]("Final total sum: " + totalSum);

3
DS 3 code

Common questions

Powered by AI

The concurrency model divides the computation workload into parallel tasks that can run simultaneously on multi-core processors, optimizing throughput. By distributing the summation task over several cores, the code effectively utilizes the parallel execution capabilities of modern processors. This method reduces overall execution time compared to sequential processing and decreases latency by allowing multiple threads to exploit processor pipelines concurrently .

Using a fixed number of threads does not account for the variability in processor core availability or workload characteristics, potentially leading to uneven load balancing if the hardware environment differs from the expected configuration. Moreover, choosing an inappropriate number of threads could lead to inefficiencies, such as overhead from context switching or underutilization of available resources. Scalability might also be limited if the problem size increases significantly without adjustment in thread count .

The design promotes computational efficiency by allowing 'SumTask' instances to run concurrently on separate processor cores. Each task handles a portion of the array, significantly reducing the time to compute the total sum compared to a single-threaded approach. By evenly distributing the workload and synchronizing task completion with 'join', the program fully utilizes available processing power and reduces bottleneck issues, which enhances overall efficiency in a multi-core environment .

The encapsulation of data and operations within the 'SumTask' class exemplifies object-oriented principles, providing a modular structure that separates computation logic for individual tasks from the main orchestration in 'DistributedSum'. This modularity facilitates code reuse and maintenance, allowing individual tasks to be easily instantiated, managed, and modified without affecting the overall system architecture, enhancing the code's adaptability and use in various contexts .

The code calculates 'chunkSize' by dividing the array length by the number of threads, assigning each 'SumTask' a unique range within the array. This deterministic assignment ensures that each thread processes an equal portion of data, minimizing synchronization overhead and maximizing concurrency. By ensuring that threads process contiguous blocks of memory, the program benefits from memory locality, which enhances performance due to optimized caching .

The code uses the 'join' method to manage thread execution flow, ensuring that the main thread waits for all 'SumTask' threads to complete execution before aggregating the partial sums. This prevents the main thread from accessing incomplete results, ensuring the correctness of the final sum. Each thread's partial result is retrieved using 'getPartialSum', which safely aggregates all contributions to calculate the total sum .

The 'DistributedSum' class initializes an array with elements 1 through N. It then divides the array size by the number of threads to determine 'chunkSize', ensuring that each thread processes an equal-sized portion of the array. The last thread is assigned any remaining elements to avoid skipping any part of the array. Each thread processes its assigned portion, ensuring complete array coverage .

The code initializes an 'array' with values from 1 to N, representing sequential integers. This sequential initialization means that each element can simply be summed without additional computation to determine individual values. The predictable and uniform distribution of values simplifies the task of balancing workload across threads, thus directly contributing to an efficient summation process .

The program employs a try-catch block around the 'join' operation to handle 'InterruptedException'. If a thread is interrupted, the catch block triggers, printing an error message. Such interruptions, while reported, could prevent a thread from completing its sum calculation, leading to incomplete aggregation of results and thus an inaccurate total sum .

The 'SumTask' class extends Thread, allowing each instance to run concurrently on separate threads. It holds a segment of an array and computes the sum of that segment when its 'run' method is invoked. This partitioning of the array allows multiple threads to process different parts of the array simultaneously, thus achieving parallel computation. The partial results are then aggregated to obtain the total sum, leveraging multi-core processors to reduce computation time .

You might also like