added threads

Author: AnuragAnalog

Linkedlist.java

@@ -0,0 +1,34 @@
+import java.util.*;
+
+public class Linkedlist {
+    public static void main(String[] args) {
+        LinkedList<String> list = new LinkedList<String>();
+        // LinkedList<String> list2 = {"This", "is", "a", "linked", "list"};
+
+        list.add("Hello");
+        list.add("World");
+        list.add("Java");
+
+        System.out.println("Printing the linked list: " + list);
+        System.out.println("Size of the linked list: " + list.size());
+        System.out.println("Element at index 1: " + list.get(1));
+        list.set(2, "Python");
+        list.addFirst("C++"); // Adds element at the beginning of the list
+        list.addLast("C#"); // Adds element at the end of the list
+        list.removeFirst(); // Removes the first occurrence of the element
+        list.add("Ravi");  
+        list.add("Vijay");  
+        list.add("Ajay");  
+        list.add("Anuj");  
+        list.removeLast(); // Removes the last occurrence of the element
+        list.add("Gaurav");  
+        list.add("Harsh");  
+        list.remove(1); // Removes the element at index 1
+        list.add("Virat");  
+        list.add("Gaurav");  
+        list.add("Harsh");  
+        list.add("Amit"); 
+        // list.addAll(list2);
+        System.out.println("Printing the linked list: " + list);
+    }
+}

MathFunc.java

@@ -0,0 +1,37 @@
+package mathfuncs;
+
+// It is a package for storing all the math related functions
+
+public class MathFunc {
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    public int subtract(int a, int b) {
+        return a - b;
+    }
+
+    public int multiply(int a, int b) {
+        return a * b;
+    }
+
+    public int divide(int a, int b) {
+        return a / b;
+    }
+
+    public int modulus(int a, int b) {
+        return a % b;
+    }
+
+    public int increment(int a) {
+        return a++;
+    }
+
+    public int decrement(int a) {
+        return a--;
+    }
+
+    public int unaryMinus(int a) {
+        return -a;
+    }
+}

This.java

@@ -1,5 +1,6 @@
 import java.util.*;
 
+import mathfuncs.*;
 // Understanding 'this' keyword
 
 public class This {
@@ -17,6 +18,8 @@ public static void main(String[] args) {
         This obj1 = new This();
         This obj2 = new This(30);
 
+        System.out.println("Age value: " + MathFunc.add(10, 20));
+
         System.out.println("Age value: " + age);
         System.out.println("Age value: " + obj1.age);
         System.out.println("Age value: " + obj2.age);

Threads.java

@@ -0,0 +1,50 @@
+import java.util.*;
+
+// Understanding Threads
+// Threads are independent paths of execution in a program, they can be used to perform tasks in parallel.
+// The life cycle of a thread in Java is controlled by the JVM. The thread states are:
+// 1. New: A new thread is created but not started.
+// 2. Runnable: A thread is ready to run and waiting for the JVM to schedule it.
+// 3. Running: The thread is being executed.
+// 4. Blocked: The thread is waiting for a monitor lock to enter a synchronized block/method.
+// 5. Waiting: The thread is waiting for another thread to perform a particular action.
+// 6. Timed Waiting: The thread is waiting for another thread to perform an action for up to a specified waiting time.
+// 7. Terminated: The thread has completed its execution.
+// To stop the main method excution, we can use the join() method. The join() method waits for the threads to die.
+// The synchronized keyword ensures that only one thread of the program executes at a time, blocking the excution of the other thread.
+
+class Counter {
+    int count = 0;
+
+    public synchronized void count() {
+        count += 1;
+    }
+}
+
+public class Threads {
+    public static void main(String[] args) throws InterruptedException {
+        Counter c = new Counter();
+    
+        Runnable hi = () -> {
+        for (int i = 0; i < 10; i++) {
+            c.count();
+        }
+    };
+        Runnable hello = () -> {
+        for (int i = 0; i < 10; i++) {
+            c.count();
+        }
+    };
+
+        Thread t1 = new Thread(hi);
+        Thread t2 = new Thread(hello);
+
+        t1.start();
+        t2.start();
+
+        t1.join();
+        t2.join();
+
+        System.out.println("Count: " + c.count);   
+    }
+}