iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

concurrent package description (#2265) 

* moving jmh into libraries module

* refactoring jmh

* Update pom.xml

* manual algorightm

* with BM result

* fix for space issue

* Fixed indentation

* change as per suggestion

* vavr either

* adding unit test and othe rutilities

* adding concurrent module

* concurrent package description

* concurrent package description

* Update EitherUnitTest.java
This commit is contained in:
Abhinab Kanrar 2017-07-19 13:46:22 +05:30 committed by Grzegorz Piwowarek
parent 5004fd96a3
commit 14456eb92d
12 changed files with 284 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
core-java/src/main/java/com/baeldung/concurrent/Scheduledexecutorservice/ScheduledExecutorServiceDemo.java Normal file
View File

@ -0,0 +1,46 @@
package com.baeldung.concurrent.Scheduledexecutorservice;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorServiceDemo {
public void execute() {
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
ScheduledFuture<?> scheduledFuture = executorService.schedule(new Runnable() {
@Override
public void run() {
// task details
}
}, 1, TimeUnit.SECONDS);
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
// task details
}
}, 1, 10, TimeUnit.SECONDS);
executorService.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
// task details
}
}, 1, 10, TimeUnit.SECONDS);
Future<String> future = executorService.schedule(new Callable<String>() {
@Override
public String call() throws Exception {
return "Hello World";
}
}, 1, TimeUnit.SECONDS);
executorService.shutdown();
}
}

27
core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierExample.java Normal file
View File

@ -0,0 +1,27 @@
package com.baeldung.concurrent.cyclicbarrier;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
public void start() {
CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("All previous tasks are completed");
}
});
Thread t1 = new Thread(new Task(cyclicBarrier), "T1");
Thread t2 = new Thread(new Task(cyclicBarrier), "T2");
Thread t3 = new Thread(new Task(cyclicBarrier), "T3");
if (!cyclicBarrier.isBroken()) {
t1.start();
t2.start();
t3.start();
}
}
}

25
core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/Task.java Normal file
View File

@ -0,0 +1,25 @@
package com.baeldung.concurrent.cyclicbarrier;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Task implements Runnable {
private CyclicBarrier barrier;
public Task(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
System.out.println("Thread : "+ Thread.currentThread().getName() + " is waiting");
barrier.await();
System.out.println("Thread : "+ Thread.currentThread().getName() + " is released");
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}

17
core-java/src/main/java/com/baeldung/concurrent/executor/ExecutorDemo.java Normal file
View File

@ -0,0 +1,17 @@
package com.baeldung.concurrent.executor;
import java.util.concurrent.Executor;
public class ExecutorDemo {
public void execute() {
Executor executor = new Invoker();
executor.execute(new Runnable() {
@Override
public void run() {
// task to be performed
}
});
}
}

12
core-java/src/main/java/com/baeldung/concurrent/executor/Invoker.java Normal file
View File

@ -0,0 +1,12 @@
package com.baeldung.concurrent.executor;
import java.util.concurrent.Executor;
public class Invoker implements Executor {
@Override
public void execute(Runnable r) {
r.run();
}
}

32
core-java/src/main/java/com/baeldung/concurrent/executorservice/ExecutorServiceDemo.java Normal file
View File

@ -0,0 +1,32 @@
package com.baeldung.concurrent.executorservice;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class ExecutorServiceDemo {
ExecutorService executor = Executors.newFixedThreadPool(10);
public void execute() {
executor.execute(new Runnable() {
@Override
public void run() {
// task details
}
});
executor.submit(new Task());
executor.shutdown();
executor.shutdownNow();
try {
executor.awaitTermination(20l, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

10
core-java/src/main/java/com/baeldung/concurrent/executorservice/Task.java Normal file
View File

@ -0,0 +1,10 @@
package com.baeldung.concurrent.executorservice;
public class Task implements Runnable {
@Override
public void run() {
// task details
}
}

47
core-java/src/main/java/com/baeldung/concurrent/future/FutureDemo.java Normal file
View File

@ -0,0 +1,47 @@
package com.baeldung.concurrent.future;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class FutureDemo {
public String invoke() {
String str = null;
ExecutorService executorService = Executors.newFixedThreadPool(10);
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(10000l);
return "Hello World";
}
});
future.cancel(false);
try {
future.get(20, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e1) {
e1.printStackTrace();
}
if (future.isDone() && !future.isCancelled()) {
try {
str = future.get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
return str;
}
}

22
core-java/src/main/java/com/baeldung/concurrent/semaphore/SemaPhoreDemo.java Normal file
View File

@ -0,0 +1,22 @@
package com.baeldung.concurrent.semaphore;
import java.util.concurrent.Semaphore;
public class SemaPhoreDemo {
static Semaphore semaphore = new Semaphore(10);
public void execute() throws InterruptedException {
System.out.println("Available permit : " + semaphore.availablePermits());
System.out.println("Number of threads waiting to acquire: " + semaphore.getQueueLength());
if (semaphore.tryAcquire()) {
semaphore.acquire();
// perform some critical operations
semaphore.release();
}
}
}

23
core-java/src/main/java/com/baeldung/concurrent/threadfactory/BaeldungThreadFactory.java Normal file
View File

@ -0,0 +1,23 @@
package com.baeldung.concurrent.threadfactory;
import java.util.concurrent.ThreadFactory;
public class BaeldungThreadFactory implements ThreadFactory {
private int threadId;
private String name;
public BaeldungThreadFactory(String name) {
threadId = 1;
this.name = name;
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r, name + "-Thread_" + threadId);
System.out.println("created new thread with id : " + threadId + " and name : " + t.getName());
threadId++;
return t;
}
}

13
core-java/src/main/java/com/baeldung/concurrent/threadfactory/Demo.java Normal file
View File

@ -0,0 +1,13 @@
package com.baeldung.concurrent.threadfactory;
public class Demo {
public void execute() {
BaeldungThreadFactory factory = new BaeldungThreadFactory("BaeldungThreadFactory");
for (int i = 0; i < 10; i++) {
Thread t = factory.newThread(new Task());
t.start();
}
}
}

10
core-java/src/main/java/com/baeldung/concurrent/threadfactory/Task.java Normal file
View File

@ -0,0 +1,10 @@
package com.baeldung.concurrent.threadfactory;
public class Task implements Runnable {
@Override
public void run() {
// task details
}
}