Threads Archives - TutorialFlow

BlockingQueue

BlockingQueue is a thread-safe queue where we can enqueue on one end of queue, and dequeue on another end of queue., All BlockingQueue implementions on array or linked queues are thread-safe implementations. Below is a simple usage of BlockingQueue.

import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueuesExamples {
	
	public static void main(String[] args) throws InterruptedException {
		
		BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>();
		
		linkedBlockingQueue.offer("Apple");
		linkedBlockingQueue.offer("Orange");
		linkedBlockingQueue.offer("Peach");
		
		queueStatus(linkedBlockingQueue);
		
		linkedBlockingQueue.offer("Avacado");
		
		queueStatus(linkedBlockingQueue);
		
		System.out.println("Dequeued at Head of Queue: " + linkedBlockingQueue.take());
		System.out.println("Dequeued at Head of Queue: " + linkedBlockingQueue.take());
		
		queueStatus(linkedBlockingQueue);
		
	}

	public static void queueStatus(Queue linkedBlockingQueue) {
		System.out.println("---------------------------");
		System.out.println("Linked Blocking Queue Size:" + linkedBlockingQueue.size());
		System.out.println("Items:");
		System.out.println(linkedBlockingQueue);
		System.out.println("---------------------------");
	}
}

import java.util.Queue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueuesExamples {

public static void main(String[] args) throws InterruptedException {

BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>();

linkedBlockingQueue.offer("Apple");

linkedBlockingQueue.offer("Orange");

linkedBlockingQueue.offer("Peach");

queueStatus(linkedBlockingQueue);

linkedBlockingQueue.offer("Avacado");

queueStatus(linkedBlockingQueue);

System.out.println("Dequeued at Head of Queue: " + linkedBlockingQueue.take());

queueStatus(linkedBlockingQueue);

}

public static void queueStatus(Queue linkedBlockingQueue) {

System.out.println("---------------------------");

System.out.println("Linked Blocking Queue Size:" + linkedBlockingQueue.size());

System.out.println("Items:");

System.out.println(linkedBlockingQueue);

System.out.println("---------------------------");

}

Output:

---------------------------
Linked Blocking Queue Size:3
Items:
[Apple, Orange, Peach]
---------------------------
---------------------------
Linked Blocking Queue Size:4
Items:
[Apple, Orange, Peach, Avacado]
---------------------------
Dequeued at Head of Queue: Apple
Dequeued at Head of Queue: Orange
---------------------------
Linked Blocking Queue Size:2
Items:
[Peach, Avacado]
---------------------------

---------------------------

Linked Blocking Queue Size:3

Items:

[Apple, Orange, Peach]

---------------------------

Linked Blocking Queue Size:4

Items:

[Apple, Orange, Peach, Avacado]

---------------------------

Dequeued at Head of Queue: Apple

Dequeued at Head of Queue: Orange

---------------------------

Linked Blocking Queue Size:2

Items:

[Peach, Avacado]

---------------------------

BlockingDeque

BlockingDeque is an extended implementation of queue where we can enqueue or dequeue on both ends of the queue. All BlockingDeque implementions on array or linked queues are thread-safe implementations. Below is a simple usage of BlockingDeque

import java.util.Queue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class BlockingQueuesExamples {
	
	public static void main(String[] args) throws InterruptedException {
		
		BlockingDeque<String> linkedBlockingDeque = new LinkedBlockingDeque<String>();
		
		linkedBlockingDeque.offer("Apple");
		linkedBlockingDeque.offer("Orange");
		linkedBlockingDeque.offer("Peach");
		
		queueStatus(linkedBlockingDeque);
		
		linkedBlockingDeque.offerFirst("Banana");
		linkedBlockingDeque.offerFirst("Guava");
		
		queueStatus(linkedBlockingDeque);
		
		linkedBlockingDeque.offerLast("Pomegranate");
		linkedBlockingDeque.offerLast("Grape");
		
		linkedBlockingDeque.offer("Avacado");
		
		// Note: offerLast() and offer() method will do the same operation...
		queueStatus(linkedBlockingDeque);
		
		System.out.println("Dequeued at Head of Queue: " + linkedBlockingDeque.takeFirst());
		System.out.println("Dequeued at Tail of Queue: " + linkedBlockingDeque.takeLast());
		System.out.println("Dequeued at Head of Queue: " + linkedBlockingDeque.take()); 
		// Note: takeFirst() and take() method will do the same operation...
		
		queueStatus(linkedBlockingDeque);
		
	}

	
	
	public static void queueStatus(Queue linkedBlockingDeque) {
		System.out.println("---------------------------");
		System.out.println("Linked Blocking Deque Size:" + linkedBlockingDeque.size());
		System.out.println("Items:");
		System.out.println(linkedBlockingDeque);
		System.out.println("---------------------------");
	}
}

import java.util.Queue;

import java.util.concurrent.BlockingDeque;

import java.util.concurrent.LinkedBlockingDeque;

public class BlockingQueuesExamples {

public static void main(String[] args) throws InterruptedException {

BlockingDeque<String> linkedBlockingDeque = new LinkedBlockingDeque<String>();

linkedBlockingDeque.offer("Apple");

linkedBlockingDeque.offer("Orange");

linkedBlockingDeque.offer("Peach");

queueStatus(linkedBlockingDeque);

linkedBlockingDeque.offerFirst("Banana");

linkedBlockingDeque.offerFirst("Guava");

queueStatus(linkedBlockingDeque);

linkedBlockingDeque.offerLast("Pomegranate");

linkedBlockingDeque.offerLast("Grape");

linkedBlockingDeque.offer("Avacado");

// Note: offerLast() and offer() method will do the same operation...

queueStatus(linkedBlockingDeque);

System.out.println("Dequeued at Head of Queue: " + linkedBlockingDeque.takeFirst());

System.out.println("Dequeued at Tail of Queue: " + linkedBlockingDeque.takeLast());

System.out.println("Dequeued at Head of Queue: " + linkedBlockingDeque.take());

// Note: takeFirst() and take() method will do the same operation...

queueStatus(linkedBlockingDeque);

}

public static void queueStatus(Queue linkedBlockingDeque) {

System.out.println("---------------------------");

System.out.println("Linked Blocking Deque Size:" + linkedBlockingDeque.size());

System.out.println("Items:");

System.out.println(linkedBlockingDeque);

System.out.println("---------------------------");

}

Output:

---------------------------
Linked Blocking Deque Size:3
Items:
[Apple, Orange, Peach]
---------------------------
---------------------------
Linked Blocking Deque Size:5
Items:
[Guava, Banana, Apple, Orange, Peach]
---------------------------
---------------------------
Linked Blocking Deque Size:8
Items:
[Guava, Banana, Apple, Orange, Peach, Pomegranate, Grape, Avacado]
---------------------------
Dequeued at Head of Queue: Guava
Dequeued at Tail of Queue: Avacado
Dequeued at Head of Queue: Banana
---------------------------
Linked Blocking Deque Size:5
Items:
[Apple, Orange, Peach, Pomegranate, Grape]
---------------------------

---------------------------

Linked Blocking Deque Size:3

Items:

[Apple, Orange, Peach]

---------------------------

Linked Blocking Deque Size:5

Items:

[Guava, Banana, Apple, Orange, Peach]

---------------------------

Linked Blocking Deque Size:8

Items:

[Guava, Banana, Apple, Orange, Peach, Pomegranate, Grape, Avacado]

---------------------------

Dequeued at Head of Queue: Guava

Dequeued at Tail of Queue: Avacado

Dequeued at Head of Queue: Banana

---------------------------

Linked Blocking Deque Size:5

Items:

[Apple, Orange, Peach, Pomegranate, Grape]

---------------------------

Threads (Runnable vs Thread)

1.What is Thread? A thread in Java is nothing but an instance of class which is running independently to complete its job.Thread is created in Java with the help of java.lang.Thread class, and hence it is controlled using the same class. Threads executes parallel without waiting for main program/each other and completes its job, unless … Continue reading “Threads (Runnable vs Thread)”

CountdownLatch

CountDownLatch is another concurrency class, in which makes one thread wait for other until it reaches the threshold limit mentioned.Reach for the threshold limit, is counted by calling countdown() method present in CountDownLatch class.Every time countdown() method is called, the count is decremented by 1, finally when arrives at zero, the awaiting will stop. Assume … Continue reading “CountdownLatch”

ForkJoinPool

ForkJoinPool is the core of the concurrency frameworks which follows divide and conquer approach in completing the tasks. Fork – Recursively break the single task into multiple smaller tasks till the threshold. Join – Join the multiple smaller tasks results and produce the output recursively. Initialise the maximum number of worker threads.

ForkJoinPool forkJoinPool = new ForkJoinPool(3);

1	ForkJoinPool forkJoinPool = new ForkJoinPool(3);

RecursiveAction class … Continue reading “ForkJoinPool”

Reentrant Lock

The ReentrantLock class is an implementation of Lock Interface, which will lock() the execution block for the thread which calls it.Until the locked thread calls the lock.unlock() method, the code block in between will not be available to other Threads…even when it is idle or sleeping or taking long time.Hence the block after lock.lock() is … Continue reading “Reentrant Lock”

Cyclic Barrier

Assume a the conference call will be opened when 4 users join., Assume until all the users join, that conference call wont be opened even when the less than 4 users join. Below example is a simple illustration of the scenario using Cyclic Barrier.

package my.test.learning;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

    public static void main(String[] args) {

        CyclicBarrier barrier = new CyclicBarrier(4);
        ChatUser user1 = new ChatUser("Jake", barrier);
        ChatUser user2 = new ChatUser("Mike", barrier);
        ChatUser user3 = new ChatUser("Don", barrier);
        ChatUser user4 = new ChatUser("Kar", barrier);
 
        user1.start();
        user2.start();
        user3.start();
        user4.start();
     }
}


class ChatUser extends Thread {
 
    private String username;
    boolean join  = false;
    boolean conferenceCallOpened = false;
    private CyclicBarrier cyclicBarrier;

    public ChatUser(String username, CyclicBarrier cyclicBarrier) {
        this.username      = username;
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
      joinedConference();
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
       openConferenceCall();
    }

   

    public void joinedConference() {
        join = true;
        System.out.println(username + " has joined the conference call..");
    }

   

    public void openConferenceCall() {
        conferenceCallOpened = true;
        System.out.println("Conference call Opened");
        // May be can write any function to open the conference call...

    }
}

package my.test.learning;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

public static void main(String[] args) {

CyclicBarrier barrier = new CyclicBarrier(4);

ChatUser user1 = new ChatUser("Jake", barrier);

ChatUser user2 = new ChatUser("Mike", barrier);

ChatUser user3 = new ChatUser("Don", barrier);

ChatUser user4 = new ChatUser("Kar", barrier);

user1.start();

user2.start();

user3.start();

user4.start();

}

class ChatUser extends Thread {

private String username;

boolean join = false;

boolean conferenceCallOpened = false;

private CyclicBarrier cyclicBarrier;

public ChatUser(String username, CyclicBarrier cyclicBarrier) {

this.username = username;

this.cyclicBarrier = cyclicBarrier;

}

@Override

public void run() {

joinedConference();

try {

cyclicBarrier.await();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

openConferenceCall();

}

public void joinedConference() {

join = true;

System.out.println(username + " has joined the conference call..");

}

public void openConferenceCall() {

conferenceCallOpened = true;

System.out.println("Conference call Opened");

// May be can write any function to open the conference call...

}

Result:

Mike has joined the conference call..
Kar has joined the conference call..
Jake has joined the conference call..
Don has joined the conference call..
Conference call Opened
Conference call Opened
Conference call Opened
Conference call Opened

Mike has joined the conference call..

Kar has joined the conference call..

Jake has joined the conference call..

Don has joined the conference call..

Conference call Opened

Executor & Executor Service

Executor and ExecutorService are the utility classes present starting from JDK 1.5 for executing a java process/block parallely in a controlled manner. Executor – Executor is used for creates a thread pool to for fixed number, using the method newFixedThreadPool. e.g., We have a 2 dimensional array where each row needs to be processed or set to … Continue reading “Executor & Executor Service”

Semaphore

A semaphore maintains a fixed number of threads in executions if exceeds lock can be acquired for that semaphore thread. Below method will get the lock of semaphore within semaphore.availablePermits()

semaphore.acquire()

1	semaphore.acquire()

If there are more that fixed threads, it will wait to acquire/get the semaphore lock until it has semaphore.availablepermits() greater than ‘0’.A semaphore initialised to … Continue reading “Semaphore”