CS计算机代考程序代写 Java concurrency flex NWEN303 Concurrent Programming

NWEN303 Concurrent Programming
2 A conceptual model for concurrency
Marco Servetto VUW

●
A conceptual model for Concurrency
In a non concurrent model of computation operations are executed one after the other in order. An operation can start only after the former operation ended.
You can visualize this model imagining yourself doing a task alone. We often talk in this way:
Here I call this function, I take the result and I transform it in this way, then I will check if ….
Divide and conquer (as for merge-sort)
●
–
●
–
If the data is a single element then it is sorted, otherwise I take the data and I split it in two roughly equal halves, I recursively sort the first half, then I recursively sort the second half, and finally I merge the two sorted halves into a single sorted result.

●
●
A conceptual model for Concurrency
In a concurrent model of computation some operations may be executed simultaneously.
This model is harder to visualize. A common metaphor is the ‘temporary work agency’: if more then one task can be performed at the same time, we call someone to help.
This model allows to generalize Divide and conquer into Fork-Join:
Fork-Join (applied to merge-sort)
●
●
–
If the data is a single element then it is sorted, otherwise I take the data and I split it in two roughly equal halves, then I delegate to another person to recursively sort the first half; while they work, I recursively sort the second half, then I collect their result, and finally I merge the two sorted halves into a single sorted result.

●
A conceptual model for Concurrency
If the various people involved in the computation have to discuss about the computation and share partial results, everything can get very complicated very fast.
Minimizing those communications and deeply understand the points where communication need to happens is the key to understand concurrent programs.
When possible, no communication is the best solution. Moreover, all mainstream languages offers libraries to make this simple case syntactically convenient.
●
●

Java parallelStream: Easy mode
public static boolean isPrime(int number){/*..*/}
public static void main(String[] arg) { List nums=new ArrayList<>(); for(int i=0;i<1000;i++) {nums.add(i);} //List primes=nums.stream()
List primes=nums.parallelStream() .filter(n->isPrime(n)) .collect(Collectors.toList());
System.out.println(nums.size()+” “+primes.size()); }
Just write .parallelStream() instead of .stream()!
Works well if the operations are fully functional! (more info later) No checked exceptions
Unchecked exceptions “sort-of” propagated
●
●
●
●

Java parallelStream: Easy mode
List data=/*some data in a list form, every element of the list is the input for an independent computation*/
List res=data.parallelStream()
.map(elem->process(elem))/*or .filter or other stream operations*/
.collect(Collectors.toList());/*collecting results*/ /*do something with res*/
To use .parallelStream() we need to write our application so that:
The data is present in some form of collection
We can define a function processing the data. Our code is wrote so that multiple concurrent executions of this function can be safely executed at the same time.
●
●
For a correct program, the semantic should not change by
writing .parallelStream() instead of .stream(), the only difference should be in the performance.
The various stream operations (map, filter, flatmap, reduce) are iconic operations in both the Map-Reduce(later in the course) and the Fork-Join model.
– –

Related Posts