迹忆客 专注技术分享

在计算机科学领域，互斥或互斥被称为并发控制的属性。每台计算机都使用称为线程的最小程序指令序列。有一次，计算机在一个线程上工作。为了更好地理解，让我们深入研究更多方面。

线程和多线程

CPU 在线程上工作以进行多任务处理。每个进程都以非常快的速度不断地从一个线程转移到另一个线程。例如，当我们观看视频时，视频的音频在不同的线程上，而图片在不同的线程上。这两者之间的不断切换是非常快的，它被称为多线程。

Java 中的线程

在 Java 中创建线程是通过扩展类和实现接口来完成的。多线程是一种 Java 特性，它允许同时执行程序的两个或多个部分，以最大限度地提高 CPU 效率。线程是此类程序的一个组件。因此，线程是进程中的轻量级进程。

互斥锁

在多线程程序中，两个或多个线程可能需要同时访问共享资源，从而导致意外行为。数据结构、输入输出设备、文件和网络连接都是共享资源的例子。

它被称为竞争条件。程序的关键部分是访问共享资源的程序部分。因此，我们必须同步对关键部分的访问以避免竞争条件。

最基本的一种同步器是互斥（或互斥），它确保一次只有一个线程可以运行计算机程序的基本区域。它由一个名为 semaphore 的类实现。

线程获取互斥锁，然后访问关键部分，最后释放互斥锁以访问关键区域。同时，所有其他线程都被阻塞，直到互斥锁被释放。线程一退出临界区就可以进入临界区。

对于互斥锁，有加锁和解锁两种方法。它们分别称为 acquire() 和 release()。现在看看下面的例子。

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
}

在上面的例子中，我们创建了两个名为 mutex 和 mutex1 的 Mutex 对象。我们将使用 mutex1 来控制两个线程之间的切换。创建链表的原因是要有线程的跟踪记录。现在，让我们在上面的代码中添加两个线程。两个线程的名称分别为 Producer 和 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();
    }
  }
}

解释

上面的代码也是不言自明的，但是这个解释将解决混淆。

Producer 线程

当你运行上面的程序时，它会创建一个 producer 线程。在该线程中，有一个 while 循环，它将无限次运行。字符串 threadName 仅用于显示线程执行。对象 mutex 将为消费者线程获取锁以使其正常工作。（Mutex 的主要目的，获得并发控制）。

之后，producer 线程开始运行。然后我们必须释放这个线程以进行生产。在 producer 线程中，我们将释放 mutex1，该对象负责处理 consumer 和 producer 之间的切换。释放后，消费者将开始消费，换句话说，消费者线程将起作用。

Consumer 线程

在我们进入 consumer 线程后，我们立即获取了 mutex1 以在消费期间停止生产。如你所见，我们在名称 C1、C2 和 C3 下创建了三个消费者。为了允许一个消费者一次运行，我们还获得了互斥锁。

之后，C1 将成为功能，而 C2 和 C3 将被回收。完成后，mutex 将再次被释放，允许其他消费者发挥作用。

这就是互斥锁在 Java 中的工作方式。运行上述程序后。它将不断显示当前正在使用的生产者线程的数量，以及使用它的消费者的名称。

随着程序运行，大小将不断增加。