Java 中的互斥锁
在计算机科学领域，互斥或互斥被称为并发控制的属性。每台计算机都使用称为线程的最小程序指令序列。有一次，计算机在一个线程上工作。为了更好地理解，让我们深入研究更多方面。
线程和多线程
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 中的工作方式。运行上述程序后。它将不断显示当前正在使用的生产者线程的数量，以及使用它的消费者的名称。
随着程序运行，大小将不断增加。
Haider specializes in technical writing. He has a solid background in computer science that allows him to create engaging, original, and compelling technical tutorials. In his free time, he enjoys adding new skills to his repertoire and watching Netflix.
LinkedIn