Initial commit

Author: orkhan-huseyn

.gitignore

@@ -0,0 +1,71 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser

.idea/description.html

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+

.idea/encodings.xml

@@ -0,0 +1,5 @@
+# Blocking Queue Implementation in Java
+
+A blocking queue is defined as a queue which blocks the caller of the enqueue method if there's no more capacity to add the new item being enqueued. 
+Similarly, the queue blocks the dequeue caller if there are no items in the queue. 
+Also, the queue notifies a blocked enqueuing thread when space becomes available and a blocked dequeuing thread when an item becomes available in the queue. 

.idea/misc.xml

@@ -0,0 +1,72 @@
+package com.learning;
+
+public class BlockingQueue<T> {
+
+    final Object lock = new Object();
+
+    T[] array;
+    int size = 0;
+    int capacity;
+    int head = 0;
+    int tail = 0;
+
+    @SuppressWarnings("unchecked")
+    public BlockingQueue(int capacity) {
+        this.capacity = capacity;
+        array = (T[]) new Object[capacity];
+    }
+
+    public void enqueue(T item) throws InterruptedException {
+        synchronized (lock) {
+            // wait for the queue to have space
+            while (size == capacity) {
+                lock.wait();
+            }
+
+            // reset tail to the beginning if the tail is already
+            // at the end of the backing array
+            if (tail == capacity) {
+                tail = 0;
+            }
+
+            // place the item in the tail
+            array[tail] = item;
+            size++;
+            tail++;
+
+            // don't forget to notify any other threads waiting on
+            // a change in value of size. There might be consumers
+            // waiting for the queue to have at least one element
+            lock.notifyAll();
+        }
+    }
+
+    public T dequeue() throws InterruptedException {
+        T item = null;
+
+        synchronized (lock) {
+            // wait for at least one item to be enqueued
+            while (size == 0) {
+                lock.wait();
+            }
+
+            // reset head to start of array if its past the array
+            if (head == capacity) {
+                head = 0;
+            }
+
+            // store the reference to the object being dequeued
+            // and overwrite with null
+            item = array[head];
+            array[head] = null;
+            head++;
+            size--;
+
+            // don't forget to call notify, there might be another thread
+            // blocked in the enqueue method.
+            lock.notifyAll();
+        }
+
+        return item;
+    }
+}

.idea/modules.xml

@@ -0,0 +1,43 @@
+package com.learning;
+
+public class Main {
+
+    public static void main(String[] args) throws InterruptedException {
+        final BlockingQueue<Integer> queue = new BlockingQueue<>(5);
+
+        Thread t1 = new Thread(() -> {
+            try {
+                for (int i = 0; i < 25; i++) {
+                    queue.enqueue(i);
+                    System.out.println("Enqueued " + i);
+                }
+            } catch (InterruptedException ignored) {}
+        });
+
+        Thread t2 = new Thread(() -> {
+            try {
+                for (int i = 0; i < 25; i++) {
+                    System.out.println("Thread 2 dequeued: " + queue.dequeue());
+                }
+            } catch (InterruptedException ignored) { }
+        });
+
+        Thread t3 = new Thread(() -> {
+            try {
+                for (int i = 0; i < 25; i++) {
+                    System.out.println("Thread 3 dequeued: " + queue.dequeue());
+                }
+            } catch (InterruptedException ignored) { }
+        });
+
+        t1.start();
+        Thread.sleep(4000);
+        t2.start();
+
+        t2.join();
+
+        t3.start();
+        t1.join();
+        t3.join();
+    }
+}