DEV Community

Cover image for Thread Concurrency In Java
Pravanjan Amanta
Pravanjan Amanta

Posted on

Thread Concurrency In Java

Thread Concurrency or Multithreading in advanced Java allows multiple threads to execute concurrently, enhancing performance and responsiveness in complex applications. Here’s a concise breakdown of its key concepts and utilities.

Key Features of Multithreading in Java:

  1. Creating Threads.
  2. Thread Management with Executors
  3. Concurrency Utilities
  4. Fork/Join Framework
  5. Asynchronous Programming with Completable Future

1️⃣ Creating Threads.

  • Extending Thread: Create a new thread by overriding the run() method.

  • Implementing Runnable: Pass a Runnable instance to a Thread object.

  • Implementing Callable: Unlike Runnable, Callable allows threads to return a result and handle checked exceptions.

2️⃣ Thread Management with Executors.

  • Java’s Executor Framework (java.util.concurrent.ExecutorService) manages thread pools, allowing efficient handling of tasks.

  • Executors like FixedThreadPool and CachedThreadPool create a pool of reusable threads, managing them efficiently to reduce the overhead of creating new threads.

3️⃣ Concurrency Utilities

  • Locks: Advanced locking mechanisms like ReentrantLock provide more flexibility than synchronized methods, allowing timed and interruptible locks.

  • Atomic Variables: The java.util.concurrent.atomic package includes atomic classes (AtomicInteger, AtomicLong) that offer lock-free thread-
    safe operations.

  • Synchronizers:include utilities like:
    CountDownLatch: Allows a thread to wait until other threads complete
    tasks.
    CyclicBarrier: Synchronizes a fixed number of threads at a common
    barrier point.
    Semaphore: Controls access to resources by allowing a specific number
    of concurrent threads.

4️⃣ Fork/Join Framework

  • 1. For divide-and-conquer tasks, ForkJoinPool splits a task into smaller subtasks that are processed in parallel, particularly useful in recursive algorithms.

5️⃣ Asynchronous Programming with Completable Future

  • CompletableFuture enables asynchronous and non-blocking programming, allowing chaining and combining tasks for complex workflows.

Using Thread Example

Main class call 2 different thread

public class ThreadConcurrence {
    public static void main(String[] args) {
        // There is 2 type you have to call thread method
                //1- Extend Thread class
                //1- Implements Runnable class
        // why Implement concept is introduce here
                // because in java multiple thread dose not support that's so why implement class will introduce
                // ex- when u extend (inherit) base call, then at that time this call can not extend another Thread class.
        int n = 10;
        for (int i = 0; i < n; i++) {

            // in case of extend(inherit) Thread class
            Thread1 t1 = new Thread1();
            t1.start();

            // in case of implement Runnable class
            Thread t2 =new Thread(new Thread2());
            t2.start();
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Thread1--(extends Thread)

public class Thread1 extends Thread{
    //If you are extend Thread class then you  most be used run()
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread1 is running now....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Thread2--(implements Runnable)

public class Thread2 implements Runnable {
    //IF you are implement thread Then run() will be executed.
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread2 is running.......");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Conclusion :

By leveraging these tools and frameworks, advanced Java multithreading enables building scalable, high-performance applications that can handle concurrent tasks seamlessly.

For more insights, feel free to mention your Linkedin and GitHub for in-depth examples and code samples! Let me know if you'd like any specific adjustments.

Linkedin : https://www.linkedin.com/in/pravanjan-17p/

GitHub : https://github.com/Prabhanjan-17p

Top comments (0)