JIYIK CN >

In the field of computer science, mutual exclusion or mutex is known as the property of concurrency control. Every computer uses a minimum sequence of program instructions called a thread. At a time, the computer works on one thread. For better understanding, let us delve into more aspects.

Threads and multithreading

The CPU works on threads for multitasking. Each process is constantly shifting from one thread to another at a very fast speed. For example, when we watch a video, the audio of the video is on a different thread and the picture is on another thread. This constant switching between the two is very fast and it is called multithreading.

Threads in Java

Creating threads in Java is done by extending classes and implementing interfaces. Multithreading is a Java feature that allows two or more parts of a program to be executed simultaneously to maximize CPU efficiency. A thread is a component of such a program. Hence, a thread is a lightweight process within a process.

Mutex

In a multithreaded program, two or more threads may need to access shared resources at the same time, resulting in unexpected behavior. Data structures, input-output devices, files, and network connections are all examples of shared resources.

It is called a race condition. The critical section of a program is the portion of the program that accesses shared resources. Therefore, we must synchronize access to the critical section to avoid race conditions.

The most basic kind of synchronizer is the mutual exclusion (or mutex), which ensures that only one thread can run a basic area of ​​a computer program at a time. It semaphoreis implemented by a class called .

A thread acquires the mutex, then accesses the critical section and finally releases the mutex to access the critical section. Meanwhile, all other threads are blocked until the mutex is released. A thread can enter the critical section as soon as it exits the critical section.

For a mutex, there are two methods for locking and unlocking. They are called acquire()and respectively release(). Now let's look at the following example.

import java.util.LinkedList; // linked list import
import java.util.concurrent.Semaphore; // semaphore import
public class Mutex {
  static LinkedList<String> WorkingQueue = new LinkedList<String>();
  // track the record of works
  static Semaphore mutex1 = new Semaphore(0); // creating a Semaphore To ImplementLogic
  static Semaphore mutex = new Semaphore(1); // Creating A Mutex
}

In the above example, we created two Mutex objects named mutexand mutex1. We will use mutex1to control the switching between the two threads. The reason for creating a linked list is to keep track of the threads. Now, let's add two threads to the above code. The names of the two threads are Producerand Consumer.

import java.util.LinkedList; // linked list import
import java.util.concurrent.Semaphore; // semaphore import
public class Mutex {
  static LinkedList<String> WorkingQueue = new LinkedList<String>();
  // track the record of works
  static Semaphore mutex1 = new Semaphore(0); // creating a Semaphore To ImplementLogic
  static Semaphore mutex = new Semaphore(1); // Creating A Mutex
  static class Producer extends Thread {
    public void run() { // default run method of thread
      int counter = 1;
      try {
        while (true) {
          String threadName = Thread.currentThread().getName()
              + counter++; // counter is added to have the thread number being used

          mutex.acquire(); // Acquiring  Lock  before Producing so the consumer cannot consume.
          WorkingQueue.add(threadName);
          System.out.println("Producer is prdoucing producing: " + threadName);
          mutex.release(); // releasing After Production ;
          mutex1.release(); // relesing lock for consumer...so consumer can consume after production
          Thread.sleep(2000); // just to Reduce the Execution Speed
        }
      } catch (Exception e) { /*nothing */
      }
    }
  }
  static class Consumer extends Thread {
    String consumerName;
    public Consumer(String name) {
      this.consumerName = name;
    }
    public void run() {
      try {
        while (true) {
          mutex1.acquire(); /// Again Acquiring So no production while consuming
          mutex.acquire(); // Acquring Other consumers lock one consume at one time
          String result = "";
          for (String value : WorkingQueue) {
            result = value + ",";
          }
          System.out.println(consumerName + " consumes value: " + result
              + "Total Size working Queue Size " + WorkingQueue.size() + "\n");
          mutex.release(); // releasing lock for other consumers.
        }
      } catch (Exception e) {
      }
    }
    public static void main(String[] args) {
      Producer producer = new Producer();

      producer.start();
      Consumer c1 = new Consumer("Bill Gates");
      Consumer c2 = new Consumer("Jeff Bezoz");
      Consumer c3 = new Consumer("Mark Zukerberg");
      c1.start();
      c2.start();
      c3.start();
    }
  }
}

explain

The code above is also self-explanatory, but this explanation will clear up the confusion.

ProducerThreads

When you run the above program, it will create a producerthread. In that thread, there is a whileloop which will run infinitely. The string threadNameis only used to show the thread execution. The object mutexwill acquire the lock for the consumer thread to work properly. (The main purpose of Mutex, to gain concurrency control).

After that, producerthe thread starts running. Then we have to release this thread to produce. In producerthe thread, we will release mutex1, the object that handles the switching between consumerand . After the release, the consumer will start consuming, in other words, the thread will work.producer消费者

ConsumerThreads

As soon as we enter consumerthe thread, we immediately acquire mutex1to stop production during consumption. As you can see, we create three consumers under the names C1, , C2and C3. To allow one consumer to run at a time, we also acquire a mutex lock.

After that, C1will become a function, while C2and C3will be recycled. Once completed, mutexwill be released again, allowing other consumers to function.

This is how mutex locks work in Java. After running the above program, it will constantly display 生产者the number of threads currently using it, along with the name of the thread using it 消费者.

As the program runs, the size will continue to increase.