Java Concurrency

public class ReadWriteLock{ private int readers = 0; private int writers = 0; private int writeRequests = 0; public synchronized void lockRead() throws InterruptedException{ while(writers > 0 || writeRequests > 0){ wait(); } readers++; } public synchronized void unlockRead(){ readers--; notifyAll(); } public synchronized void lockWrite() throws InterruptedException{ writeRequests++; while(readers > 0 || writers > 0){ wait(); } writeRequests--; writers++; } public synchronized void unlockWrite() throws InterruptedException{ writers--; notifyAll(); } }

There are 3 threads.

First thread prints 1111... Second prints 2222.. Third prints 33333..

How to schedule threads to print 123123123...?

Create 3 printing threads and store them in array

main:

while(true) {

synchronized(threads[i]){threads[i].notify();}

try {Thread.sleep(10);}

i=(++i) % 3

}

class MyThread extends Thread {

private int value;

void run() {

while(true){

synchronized(this) {

try{wait();}

System.output.print(value);

}

}

}

https://habrahabr.ru/company/luxoft/blog/157273/

https://habrahabr.ru/post/277669/

https://bmwieczorek.wordpress.com/2016/06/21/multiple-approaches-to-concurrent-processing-in-java/

http://fahdshariff.blogspot.com/2016/06/java-8-completablefuture-vs-parallel.html

http://www.java-success.com/10-%E2%99%A6-executorservice-vs-forkjoin-future-vs-completablefuture-interview-qa/

assume we want to execute 2 long running operations: download content and parse it and we want to do it for the list of resources.

The blog points multiple approaches:

1) Thread(s)

2) ExecutorService to submit Callable and return blocking Future get()

3) ExecutionCompletionService implementing CompletionService to submit Callable and returning Future. CompletionService has take or poll methods waiting and returning first completed task (returned Future’s get() is not blocking)

4) Parallel streams

5) CompletableFuture

The use cases for the fork/join are pretty narrow. It can only be used when the following conditions are met.

1) The data-set is large & efficiently splittable.

2) The operations performed on individual data items should be reasonably independent of each other.

3) The operations should be expensive & CPU intensive.

When the above conditions do not hold, and your use case is more I/O or network intensive then use ExecutorService with CompletableFuture.

CompletableFuture https://blog.cngroup.dk/2015/08/04/completable-future/

examples what we can do with CompletableFuture:

• 1. Combine several asynchronous operation

  2. Wait for task completion

  3. Listen to Future completion and react to it success or error completion

  4. Chaining results of dependent futures

http://stackoverflow.com/questions/33944471/forkjointask-vs-completablefuture

In Java 8 there are two ways of starting asynchronous computations - CompletableFuture and ForkJoinTask.

They both seem fairly similar - the inner classes of CompletableFuture even extend ForkJoinTask.

ForkJoinTask is more recommended when you have a big task and want to split it to run in parallel in several sub tasks. The ForkJoin framework uses the work stealing algorithm which will make an efficient use of the threads. On the other hand, CompletableFutures are more appropriate for a Reactive programming model, where you can create pipelines of execution in a sync or async fashion, and have a better control of the threads by using the thread pools of the Executor Service.

Distributing the Work with the ExecutorService

Say you have 100,000 CPU-intensive tasks, and your computer has 8 cores, which means it could run 8 tasks at the same time (aka “in parallel”). If you run them all in one thread, you only get 1/8 the speed. When you create threads, Java will run them on the available cores for you.

However, you don’t want to create 100,000 separate threads all at once, because it would use up a lot of system resources, be hard to manage, and run slowly due to the CPU having to bounce back and forth between all the threads constantly.

A better way would be to create 8 threads, one per core, and distribute the tasks to them as they complete. This is known as a “thread pool”, and it gives you better parallelism and efficiency, but would be complicated to do manually. With Executors, you can do it in one line of code with Executors.newFixedThreadPool(8):

view plaincopy to clipboardprint?

1. ExecutorService execService = Executors.newFixedThreadPool(8); // 8 threads

2. for (int i = 0; i < 100000, i++) {

3. // you can submit a Runnable, or even a Callable and get a Future

4. // object representing the result

5. execService.submit(() -> doIntensiveTask(a, b, c));

6. }

7. execService.shutdown(); // starts the shutdown process

8. execService.awaitTermination(2, TimeUnit.HOURS); // Blocks w/timeout

We can see that an Executor is an object that runs Runnable tasks, and the ExecutorService lets you control those tasks. It generally handles creating Threads for you as necessary, and lets you separate the decision of how many threads to run and when, from the logic of your program.

http://blog.takipi.com/java-8-stampedlocks-vs-readwritelocks-and-synchronized/

https://www.youtube.com/watch?v=Xi4OrmWZGCA&feature=youtu.be

http://www.discoversdk.com/blog/threading-and-synchronization-in-java

https://habrahabr.ru/post/319036/

http://www.byteslounge.com/tutorials/java-8-consumer-and-supplier

http://www.byteslounge.com/subcategory/java-concurrency

https://medium.com/@bizzard4/producer-consumer-the-whole-story-e0b4034406f1#.et0r9bpcn

https://github.com/bizzard4/SynchronizationPrimitives

http://www.discoversdk.com/blog/java-atomic-variables-and-concurrentmap

http://www.javaworld.com/article/2078848/java-concurrency/java-concurrency-java-101-the-next-generation-java-concurrency-without-the-pain-part-2.html

http://docs.oracle.com/javase/tutorial/essential/concurrency/

https://dzone.com/articles/reentrantlock-cheat-sheet

https://github.com/JCTools/JCTools

http://www.slideshare.net/elizarov/ss-61415341 multithreading

http://tutorials.jenkov.com/java-concurrency/concurrency-models.html

http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-examples/

http://www.javatpointtutorial.net/multithreading-examples-programs-with-output/

http://habrahabr.ru/post/143237/

http://habrahabr.ru/post/133981/

http://habrahabr.ru/post/128985/ Fork Join

http://habrahabr.ru/post/73249/ ExecutorService

https://habrahabr.ru/post/272479/

http://codurance.com/2016/08/24/the-java-synchronisers/

http://codingjunkie.net/completable-futures-part1/

http://java.sun.com/docs/books/tutorial/essential/concurrency

http://www.briangoetz.com/pubs.html

http://habrahabr.ru/post/143237/

syncronized locks the object, not the method or code (it means that 2 threads cannot run on the same object).

Constructors cannot be synchronized.

syncronized static void foo() - the lock is associated with Class object

Excessive use of the synchronized keyword may be counterproductive as code scales up. The java.util.concurrent package offers a range of lightweight and flexible tools for most of your needs.

The Semaphore class provides easily understood semantics and powerful capabilities in the form of methods such as acquire(), release(), etc. In addition, you can allow a semaphore to have a specific number of slots for callers to use, after which further callers are blocked.

Concurrent locks such as ReentrantLock() are even more flexible, allowing for a timed retry mechanism and the ability to check the number of outstanding attempts to lock the resource.