java parallel assignment

The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available. See Java Language Changes for a summary of updated language features in Java SE 9 and subsequent releases. See JDK Release Notes for information about new features, enhancements, and removed or deprecated options for all JDK releases.

Parallelism

Parallel computing involves dividing a problem into subproblems, solving those problems simultaneously (in parallel, with each subproblem running in a separate thread), and then combining the results of the solutions to the subproblems. Java SE provides the fork/join framework , which enables you to more easily implement parallel computing in your applications. However, with this framework, you must specify how the problems are subdivided (partitioned). With aggregate operations, the Java runtime performs this partitioning and combining of solutions for you.

One difficulty in implementing parallelism in applications that use collections is that collections are not thread-safe, which means that multiple threads cannot manipulate a collection without introducing thread interference or memory consistency errors . The Collections Framework provides synchronization wrappers , which add automatic synchronization to an arbitrary collection, making it thread-safe. However, synchronization introduces thread contention . You want to avoid thread contention because it prevents threads from running in parallel. Aggregate operations and parallel streams enable you to implement parallelism with non-thread-safe collections provided that you do not modify the collection while you are operating on it.

Note that parallelism is not automatically faster than performing operations serially, although it can be if you have enough data and processor cores. While aggregate operations enable you to more easily implement parallelism, it is still your responsibility to determine if your application is suitable for parallelism.

This section covers the following topics:

Executing Streams in Parallel

Concurrent reduction, interference, stateful lambda expressions.

You can find the code excerpts described in this section in the example ParallelismExamples .

You can execute streams in serial or in parallel. When a stream executes in parallel, the Java runtime partitions the stream into multiple substreams. Aggregate operations iterate over and process these substreams in parallel and then combine the results.

When you create a stream, it is always a serial stream unless otherwise specified. To create a parallel stream, invoke the operation Collection.parallelStream . Alternatively, invoke the operation BaseStream.parallel . For example, the following statement calculates the average age of all male members in parallel:

Consider again the following example (which is described in the section Reduction ) that groups members by gender. This example invokes the collect operation, which reduces the collection roster into a Map :

The following is the parallel equivalent:

This is called a concurrent reduction . The Java runtime performs a concurrent reduction if all of the following are true for a particular pipeline that contains the collect operation:

• The stream is parallel.
• The parameter of the collect operation, the collector, has the characteristic Collector.Characteristics.CONCURRENT . To determine the characteristics of a collector, invoke the Collector.characteristics method.
• Either the stream is unordered, or the collector has the characteristic Collector.Characteristics.UNORDERED . To ensure that the stream is unordered, invoke the BaseStream.unordered operation.

Note : This example returns an instance of ConcurrentMap instead of Map and invokes the groupingByConcurrent operation instead of groupingBy . (See the section Concurrent Collections for more information about ConcurrentMap .) Unlike the operation groupingByConcurrent , the operation groupingBy performs poorly with parallel streams. (This is because it operates by merging two maps by key, which is computationally expensive.) Similarly, the operation Collectors.toConcurrentMap performs better with parallel streams than the operation Collectors.toMap .

The order in which a pipeline processes the elements of a stream depends on whether the stream is executed in serial or in parallel, the source of the stream, and intermediate operations. For example, consider the following example that prints the elements of an instance of ArrayList with the forEach operation several times:

This example consists of five pipelines. It prints output similar to the following:

This example does the following:

• The first pipeline prints the elements of the list listOfIntegers in the order that they were added to the list.
• The second pipeline prints the elements of listOfIntegers after it was sorted by the method Collections.sort .
• The third and fourth pipelines print the elements of the list in an apparently random order. Remember that stream operations use internal iteration when processing elements of a stream. Consequently, when you execute a stream in parallel, the Java compiler and runtime determine the order in which to process the stream's elements to maximize the benefits of parallel computing unless otherwise specified by the stream operation.
• The fifth pipeline uses the method forEachOrdered , which processes the elements of the stream in the order specified by its source, regardless of whether you executed the stream in serial or parallel. Note that you may lose the benefits of parallelism if you use operations like forEachOrdered with parallel streams.

Side Effects

A method or an expression has a side effect if, in addition to returning or producing a value, it also modifies the state of the computer. Examples include mutable reductions (operations that use the collect operation; see the section Reduction for more information) as well as invoking the System.out.println method for debugging. The JDK handles certain side effects in pipelines well. In particular, the collect method is designed to perform the most common stream operations that have side effects in a parallel-safe manner. Operations like forEach and peek are designed for side effects; a lambda expression that returns void, such as one that invokes System.out.println , can do nothing but have side effects. Even so, you should use the forEach and peek operations with care; if you use one of these operations with a parallel stream, then the Java runtime may invoke the lambda expression that you specified as its parameter concurrently from multiple threads. In addition, never pass as parameters lambda expressions that have side effects in operations such as filter and map . The following sections discuss interference and stateful lambda expressions , both of which can be sources of side effects and can return inconsistent or unpredictable results, especially in parallel streams. However, the concept of laziness is discussed first, because it has a direct effect on interference.

All intermediate operations are lazy . An expression, method, or algorithm is lazy if its value is evaluated only when it is required. (An algorithm is eager if it is evaluated or processed immediately.) Intermediate operations are lazy because they do not start processing the contents of the stream until the terminal operation commences. Processing streams lazily enables the Java compiler and runtime to optimize how they process streams. For example, in a pipeline such as the filter - mapToInt - average example described in the section Aggregate Operations , the average operation could obtain the first several integers from the stream created by the mapToInt operation, which obtains elements from the filter operation. The average operation would repeat this process until it had obtained all required elements from the stream, and then it would calculate the average.

Lambda expressions in stream operations should not interfere . Interference occurs when the source of a stream is modified while a pipeline processes the stream. For example, the following code attempts to concatenate the strings contained in the List listOfStrings . However, it throws a ConcurrentModificationException :

This example concatenates the strings contained in listOfStrings into an Optional<String> value with the reduce operation, which is a terminal operation. However, the pipeline here invokes the intermediate operation peek , which attempts to add a new element to listOfStrings . Remember, all intermediate operations are lazy. This means that the pipeline in this example begins execution when the operation get is invoked, and ends execution when the get operation completes. The argument of the peek operation attempts to modify the stream source during the execution of the pipeline, which causes the Java runtime to throw a ConcurrentModificationException .

Avoid using stateful lambda expressions as parameters in stream operations. A stateful lambda expression is one whose result depends on any state that might change during the execution of a pipeline. The following example adds elements from the List listOfIntegers to a new List instance with the map intermediate operation. It does this twice, first with a serial stream and then with a parallel stream:

The lambda expression e -> { parallelStorage.add(e); return e; } is a stateful lambda expression. Its result can vary every time the code is run. This example prints the following:

The operation forEachOrdered processes elements in the order specified by the stream, regardless of whether the stream is executed in serial or parallel. However, when a stream is executed in parallel, the map operation processes elements of the stream specified by the Java runtime and compiler. Consequently, the order in which the lambda expression e -> { parallelStorage.add(e); return e; } adds elements to the List parallelStorage can vary every time the code is run. For deterministic and predictable results, ensure that lambda expression parameters in stream operations are not stateful.

Note : This example invokes the method synchronizedList so that the List parallelStorage is thread-safe. Remember that collections are not thread-safe. This means that multiple threads should not access a particular collection at the same time. Suppose that you do not invoke the method synchronizedList when creating parallelStorage :

The example behaves erratically because multiple threads access and modify parallelStorage without a mechanism like synchronization to schedule when a particular thread may access the List instance. Consequently, the example could print output similar to the following:

About Oracle | Contact Us | Legal Notices | Terms of Use | Your Privacy Rights

Copyright © 1995, 2022 Oracle and/or its affiliates. All rights reserved.

• Top Courses
• Online Degrees
• Find your New Career
• Join for Free

Parallel, Concurrent, and Distributed Programming in Java Specialization

Boost Your Programming Expertise with Parallelism. Learn the fundamentals of parallel, concurrent, and distributed programming.

Taught in English

Some content may not be translated

Instructor: Vivek Sarkar

Financial aid available

24,611 already enrolled

Specialization - 3 course series

(1,331 reviews)

Skills you'll gain

• Distributed Computing
• Optimistic Concurrency Control
• Parallel Computing
• Java Concurrency

Details to know

Add to your LinkedIn profile

See how employees at top companies are mastering in-demand skills

Advance your subject-matter expertise

• Learn in-demand skills from university and industry experts
• Master a subject or tool with hands-on projects
• Develop a deep understanding of key concepts
• Earn a career certificate from Rice University

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV

Share it on social media and in your performance review

Parallel, concurrent, and distributed programming underlies software in multiple domains, ranging from biomedical research to financial services. This specialization is intended for anyone with a basic knowledge of sequential programming in Java, who is motivated to learn how to write parallel, concurrent and distributed programs. Through a collection of three courses (which may be taken in any order or separately), you will learn foundational topics in Parallelism, Concurrency, and Distribution. These courses will prepare you for multithreaded and distributed programming for a wide range of computer platforms, from mobile devices to cloud computing servers.

To see an overview video for this Specialization, click here Opens in a new tab ! For an interview with two early-career software engineers on the relevance of parallel computing to their jobs, click here Opens in a new tab .

Acknowledgments

The instructor, Prof. Vivek Sarkar, would like to thank Dr. Max Grossman for his contributions to the mini-projects and other course material, Dr. Zoran Budimlic for his contributions to the quizzes, Dr. Max Grossman and Dr. Shams Imam for their contributions to the pedagogic PCDP library used in some of the mini-projects, and all members of the Rice Online team who contributed to the development of the course content (including Martin Calvi, Annette Howe, Seth Tyger, and Chong Zhou).

Applied Learning Project

Each course includes mini-projects that will enable learners to gain hands-on experience with popular Java API’s for parallel, concurrent, and distributed programming. The mini-projects have been extracted from real-world problems in multiple domains.

Parallel Programming in Java

What you'll learn.

This course teaches learners (industry professionals and students) the fundamental concepts of parallel programming in the context of Java 8. Parallel programming enables developers to use multicore computers to make their applications run faster by using multiple processors at the same time. By the end of this course, you will learn how to use popular parallel Java frameworks (such as ForkJoin, Stream, and Phaser) to write parallel programs for a wide range of multicore platforms including servers, desktops, or mobile devices, while also learning about their theoretical foundations including computation graphs, ideal parallelism, parallel speedup, Amdahl's Law, data races, and determinism.

Why take this course? • All computers are multicore computers, so it is important for you to learn how to extend your knowledge of sequential Java programming to multicore parallelism. • Java 7 and Java 8 have introduced new frameworks for parallelism (ForkJoin, Stream) that have significantly changed the paradigms for parallel programming since the early days of Java. • Each of the four modules in the course includes an assigned mini-project that will provide you with the necessary hands-on experience to use the concepts learned in the course on your own, after the course ends. • During the course, you will have online access to the instructor and the mentors to get individualized answers to your questions posted on forums. The desired learning outcomes of this course are as follows: • Theory of parallelism: computation graphs, work, span, ideal parallelism, parallel speedup, Amdahl's Law, data races, and determinism • Task parallelism using Java’s ForkJoin framework • Functional parallelism using Java’s Future and Stream frameworks • Loop-level parallelism with extensions for barriers and iteration grouping (chunking) • Dataflow parallelism using the Phaser framework and data-driven tasks Mastery of these concepts will enable you to immediately apply them in the context of multicore Java programs, and will also provide the foundation for mastering other parallel programming systems that you may encounter in the future (e.g., C++11, OpenMP, .Net Task Parallel Library).

Concurrent Programming in Java

This course teaches learners (industry professionals and students) the fundamental concepts of concurrent programming in the context of Java 8. Concurrent programming enables developers to efficiently and correctly mediate the use of shared resources in parallel programs. By the end of this course, you will learn how to use basic concurrency constructs in Java such as threads, locks, critical sections, atomic variables, isolation, actors, optimistic concurrency and concurrent collections, as well as their theoretical foundations (e.g., progress guarantees, deadlock, livelock, starvation, linearizability).

Why take this course? • It is important for you to be aware of the theoretical foundations of concurrency to avoid common but subtle programming errors. • Java 8 has modernized many of the concurrency constructs since the early days of threads and locks. • During the course, you will have online access to the instructor and mentors to get individualized answers to your questions posted on the forums. • Each of the four modules in the course includes an assigned mini-project that will provide you with the necessary hands-on experience to use the concepts learned in the course on your own, after the course ends. The desired learning outcomes of this course are as follows: • Concurrency theory: progress guarantees, deadlock, livelock, starvation, linearizability • Use of threads and structured/unstructured locks in Java • Atomic variables and isolation • Optimistic concurrency and concurrent collections in Java (e.g., concurrent queues, concurrent hashmaps) • Actor model in Java Mastery of these concepts will enable you to immediately apply them in the context of concurrent Java programs, and will also help you master other concurrent programming system that you may encounter in the future (e.g., POSIX threads, .NET threads).

Distributed Programming in Java

This course teaches learners (industry professionals and students) the fundamental concepts of Distributed Programming in the context of Java 8. Distributed programming enables developers to use multiple nodes in a data center to increase throughput and/or reduce latency of selected applications. By the end of this course, you will learn how to use popular distributed programming frameworks for Java programs, including Hadoop, Spark, Sockets, Remote Method Invocation (RMI), Multicast Sockets, Kafka, Message Passing Interface (MPI), as well as different approaches to combine distribution with multithreading.

Why take this course? • All data center servers are organized as collections of distributed servers, and it is important for you to also learn how to use multiple servers for increased bandwidth and reduced latency. • In addition to learning specific frameworks for distributed programming, this course will teach you how to integrate multicore and distributed parallelism in a unified approach. • Each of the four modules in the course includes an assigned mini-project that will provide you with the necessary hands-on experience to use the concepts learned in the course on your own, after the course ends. • During the course, you will have online access to the instructor and the mentors to get individualized answers to your questions posted on forums. The desired learning outcomes of this course are as follows: • Distributed map-reduce programming in Java using the Hadoop and Spark frameworks • Client-server programming using Java's Socket and Remote Method Invocation (RMI) interfaces • Message-passing programming in Java using the Message Passing Interface (MPI) • Approaches to combine distribution with multithreading, including processes and threads, distributed actors, and reactive programming Mastery of these concepts will enable you to immediately apply them in the context of distributed Java programs, and will also provide the foundation for mastering other distributed programming frameworks that you may encounter in the future (e.g., in Scala or C++).

Rice University is consistently ranked among the top 20 universities in the U.S. and the top 100 in the world. Rice has highly respected schools of Architecture, Business, Continuing Studies, Engineering, Humanities, Music, Natural Sciences and Social Sciences and is home to the Baker Institute for Public Policy.

Why people choose Coursera for their career

New to Software Development? Start here.

Open new doors with Coursera Plus

Unlimited access to 7,000+ world-class courses, hands-on projects, and job-ready certificate programs - all included in your subscription

Advance your career with an online degree

Earn a degree from world-class universities - 100% online

Join over 3,400 global companies that choose Coursera for Business

Upskill your employees to excel in the digital economy

Frequently asked questions

How long does it take to complete the specialization.

There are 3 courses in this Specialization. Based on a weekly commitment of 4-8 hours, you should be able to complete the Specialization in 12 weeks.

What background knowledge is necessary?

The Specialization is targeted at an audience that is already familiar with sequential programming in Java, including a basic knowledge of Java 8 lambdas.

Do I need to take the courses in a specific order?

No, you can take the courses in this Specialization in any order.

Will I earn university credit for completing the Specialization?

You will not earn university credit for completing the Specialization.

What will I be able to do upon completing the Specialization?

This course teaches industry professionals and students the fundamental concepts of parallel programming in the context of Java 8. Parallel programming enables developers to use multicore computers to make their applications run faster by using multiple processors at the same time. By the end of this course, you will learn how to use popular parallel Java frameworks such as ForkJoin and Stream to write parallel programs for a wide range of multicore platforms whether for servers, desktops, or mobile devices, while also learning about their theoretical foundations (e.g., deadlock freedom, data race freedom, determinism).

Is this course really 100% online? Do I need to attend any classes in person?

This course is completely online, so there’s no need to show up to a classroom in person. You can access your lectures, readings and assignments anytime and anywhere via the web or your mobile device.

What is the refund policy?

If you subscribed, you get a 7-day free trial during which you can cancel at no penalty. After that, we don’t give refunds, but you can cancel your subscription at any time. See our full refund policy Opens in a new tab .

Can I just enroll in a single course?

Yes! To get started, click the course card that interests you and enroll. You can enroll and complete the course to earn a shareable certificate, or you can audit it to view the course materials for free. When you subscribe to a course that is part of a Specialization, you’re automatically subscribed to the full Specialization. Visit your learner dashboard to track your progress.

Is financial aid available?

Yes. In select learning programs, you can apply for financial aid or a scholarship if you can’t afford the enrollment fee. If fin aid or scholarship is available for your learning program selection, you’ll find a link to apply on the description page.

Can I take the course for free?

When you enroll in the course, you get access to all of the courses in the Specialization, and you earn a certificate when you complete the work. If you only want to read and view the course content, you can audit the course for free. If you cannot afford the fee, you can apply for financial aid Opens in a new tab .

More questions

Edd Mann Developer

Parallel summation in java.

Summation is the common operation of adding a sequence of numbers together, resulting in their total. The trivial implementation is to iterate over the full collection of numbers, keeping a running total as you progress. For small sequences, a single threaded implementation will suffice, however, when the size increases use of other available CPU cores helps provide necessary speed optimisations. As addition is an associative operation it makes no difference to the end result in which order we process the collection, this behavior works well for are implementation design. Below is an example implementation which splits the summation of a sequence of numbers into (close to) equal collections, each being processed in parallel within their own thread.

Looking at the implementation above you will notice that I have taken advantage of static functionality to combine both the sum and thread instances required to complete the task. Calling ‘parallelSum’ with a single argument (being the specified array), the system is queried on how many available processing cores are present. We then create ‘Summation’ instances that are supplied with the low and high range of indexes within the subject array they are required to process. These are then started and subsequently joined into the main thread for the final round of partial sum addition to complete the process.

So as to see the benefits of parallelising such an operation, an example benchmark has been provided below. The implementation is provided in this case with 100,000,000 random integers between 1 and 100, and timed on its performance to run as both a single and parallel operation.

Looking at the results above, you will see that using the parallelised approach provides us with noticeable speed gains. An interesting observation I made when running the benchmark was that the speed increases after splitting the subject operation into 2 threads did not significantly alter the time taken.

• JDK-6664637

Parallel assignment

• Resolution: Duplicate

• Fix Version/s: None
• Affects Version/s: 7
• Component/s: specification
• Subcomponent: language
• OS: windows_xp

Description

Attachments, issue links.

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Parallel, Concurrent, and Distributed Programming in Java Specialization

igorfyago/Coursera-Spec-Java--Parallel-Concurrent-Distributed

Folders and files, repository files navigation, parallel, concurrent, distributed, programming in java specialization - rice u..

Parallel Computing

• 1.1 Task Creation and Termination (Async, Finish)
• 1.2 Tasks in Java's Fork/Join Framework
• 1.3 Computation Graphs, Work, Span
• 1.4 Multiprocessor Scheduling, Parallel Speedup
• 1.5 Amdahl's Law
• Mini Project 1: Reciprocal-Array-Sum using the Java Fork/Join Framework
• 2.1 Futures: Tasks with Return Values
• 2.2 Futures in Java's Fork/Join Framework
• 2.3 Memoization
• 2.4 Java Streams
• 2.5 Data Races and Determinism
• Mini Project 2: Analyzing Student Statistics Using Java Parallel Streams
• 3.1 Parallel Loops
• 3.2 Parallel Matrix Multiplication
• 3.3 Barriers in Parallel Loops
• 3.4 Parallel One-Dimensional Iterative Averaging
• 3.5 Iteration Grouping/Chunking in Parallel Loops
• Mini Project 3: Parallelizing Matrix-Matrix Multiply Using Loop Parallelism
• 4.1 Split-phase Barriers with Java Phasers
• 4.2 Point-to-Point Sychronization with Phasers
• 4.3 One-Dimensional Iterative Averaging with Phasers
• 4.4 Pipeline Parallelism
• 4.5 Data Flow Parallelism
• Mini Project 4: Using Phasers to Optimize Data-Parallel Applications

Concurrent Programming:

• 1.1 Threads
• 1.2 Structured Locks
• 1.3 Unstructured Locks
• 1.4 Liveness
• 1.5 Dining Philosophers
• Mini Project 1: Locking and Synchronization
• 2.1 Critical Sections
• 2.2 Object Based Isolation (Monitors)
• 2.3 Concurrent Spanning Tree Algorithm
• 2.4 Atomic Variables
• 2.5 Read, Write Isolation
• Mini Project 2: Global and Object-Based Isolation
• 3.2 Actor Examples
• 3.3 Sieve of Eratosthenes Algorithm
• 3.4 Producer-Consumer Problem
• 3.5 Bounded Buffer Problem
• Mini Project 3: Sieve of Eratosthenes Using Actor Parallelism
• 4.1 Optimistic Concurrency
• 4.2 Concurrent Queue
• 4.3 Linearizability
• 4.4 Concurrent Hash Map
• 4.5 Concurrent Minimum Spanning Tree Algorithm
• Mini Project 4: Parallelization of Boruvka's Minimum Spanning Tree Algorithm

Distributed Computing

• 1.1 Introduction to Map-Reduce
• 1.2 Hadoop Framework
• 1.3 Spark Framework
• 1.4 TF-IDF Example
• 1.5 Page Rank Example
• Mini Project 1: Page Rank with Spark
• 2.1 Introduction to Sockets
• 2.2 Serialization/Deserialization
• 2.3 Remote Method Invocation
• 2.4 Multicast Sockets
• 2.5 Publish-Subscribe Model
• Mini Project 2: File Server
• 3.1 Single Program Multiple Data (SPMD) model
• 3.2 Point-to-Point Communication
• 3.3 Message Ordering and Deadlock
• 3.4 Non-Blocking Communications
• 3.5 Collective Communication
• Mini Project 3: Matrix Multiply in MPI
• 4.1 Processes and Threads
• 4.2 Multithreaded Servers
• 4.3 MPI and Threading
• 4.4 Distributed Actors
• 4.5 Distributed Reactive Programming
• Mini Project 4: Multi-Threaded File Server
• Java 100.0%