OCP - 3

• The stream is parallel
• The parameter of the collect operation has the Collectior.Characteristics.CONCURRENT characteristic
• Either the stream is unordered, or the collect operation has the Collectior.Characteristics.UNORDERED characteristic

It syncs n threads at a given Point (Zoo example: First all must empty the cage in parallel, then they all start at the same time to clean and sync again before letting in the Animals). The number of threds to wait for is provided over the constructor.

await

Yes, after the barrier is broken, the nuber of waiting threads is set back to 0 and the class can hence be reusd

The nuber of avaiblabe threads must be at least as large as the CyclicBarrier limit. Otherwise, the barrier can never complete

Divide an Conquer: DIvide a task into recursive subtasks adding concurrency with each division. A potential result is then aggergated and returned

1. Create a ForkJoinTask
   • ForkJoinTask<?> task = new MyActionOrTask(...);
2. Create the ForkJoinPool
   • ForkJoinPool pool = new ForkJoinPool();
3. Start the ForkJoinTask
   • pool.invoke(action)
   • Object result = pool.invoke(task);

• RecursiveAction has no return type
• RecursiveTask returns a generic type

• RecursiveAction just calls invokeAll(new MyAction(...), new Action(...)) as it is "fire and forget"
• RecursiveTask is more complex:
  • RecursiveTask<Double> otherTask = new MyTask(...);
    otherTask.fork();
    return new MyTask(...).compute() + otherTask.join()

Yes, very much!

fork() starts the execution of a task while join() await's its completeness. If you call join() before calling compute(), the tasks are not executed in parallel!

It submits a task to the pool

casues the current thread to wait for the result of a subtask

It computes the task. When called in the compute method itself, it is calculated within the current thread

Via the constructor as the compute method does not take any arguments

A deadloc occurs when two or more threads are blocked forever

When a single thread is perpetually denied access to a shared resource

A livelock is a form of sttarvation where tow or more threads are active but conceptually blocked forever

When two or more threads execute at the same time, resulting in an upexpected outcome

No

A file or directory on the local disk

• System.getProperty("file.separator")
• java.io.File.separator

The number of bytes in the file, might be more than the actual usage for performance reasons

It returns the abstract pathname (as String!) of the Parent of this File or Directory or null if it does not name a parent direcotry

STreams should be conceptually thought of as a long, nearly never-ending "stream of water" with data presented one "wave" at a time.

• For Inputting and outputting all types of binary data, InputStreams and OutputStreams are used
• For Inputting and outputting character and String data, Readers and Writers are used
  • Basically, Readers and Writers are convenience for Characters. They are conceptually the same

• Low-Level streams connect directly with the source of data, such a file, an array or a string. Eg. a FileInputStream
  • Define basic methods such as read() and close()
• High-Level streams are built on to of other streams usingwrapping. Eg. a BufferedReader / BufferedInputStream
  • Provide additional convenience methods such as readLine()

They usually improve the performance singificantly.

They are all abstract classes and the basis for all specialized Readers,Writers,In- and Outputstreams

No, when wrapping a stream you can mix and match only types that inherit from the same abstract parent stream

By wrapping it with a InputStreamReader

They write formatted representations of Java objects to a binary stream

Yes, and you should do it!

For performance, not every write operation is written to the disk/network immediately. Using flush, the OS is requested to actually do it, which might take a while. Call it when it should go, but don't do it to often (expensive)

• It marks a position in the stream to jump back later using reset()
• Not all streams support this: Check with markSupported() first!
• The method takes a readlimit in bytes. After that many bytes, the mark position gets invalidated.
  • Calling reset afterwards might throw an IOException