Example of mutex semaphore and multi-thread waiting mechanism in Java

This article mainly introduces mutex locks, semaphores and multi-thread waiting mechanism examples in Java programming. It briefly introduces the difference between mutex locks and semaphores. Friends who need it can learn more.

Mutex locks and semaphores are basic concepts designed for concurrent programming in the operating system. The conceptual difference between mutex locks and semaphores is that for the same resource, mutual exclusion Locks only have the concept of 0 and 1, but semaphores are more than that. In other words, the semaphore can enable the resource to be accessed by multiple threads at the same time, while the mutex can only be accessed by one thread at the same time.
The implementation of the mutex in java is ReetranLock. When accessing a synchronized resource, its The object needs to obtain this lock through the tryLock() method. If it fails, it returns false, and if it succeeds, it returns true. Determine whether to access the synchronized resource based on the returned information. Look at the following example

public class ReentranLockExample {
 private static int count = 0;
 private static ReentrantLock reentrantLock = new ReentrantLock();
 static class MyThread extends Thread{
  @Override
  public void run() {
   super.run();
   try {
    while (true){
     boolean result = reentrantLock.tryLock();
     if (result){
      System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count ++);
      reentrantLock.unlock();
     }else{
      System.out.println(Thread.currentThread().getName() + "get the lock failed and run the syn code " + count);
     }
     System.out.println(Thread.currentThread().getName() + "run the asyntronized code " + count);
     Thread.sleep(500);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread();
  MyThread thread2 = new MyThread();
  thread1.start();
  thread2.start();
 }
}

The semaphore is equivalent to a counter. If the thread wants to access a resource, it must first obtain the semaphore of the resource, and the semaphore internal The counter is decremented by 1. The internal counter of the semaphore is greater than 0, which means that there are resources that can be used. When the thread finishes using a resource, the semaphore of this resource must be released. One of the functions of a semaphore is to specify a thread to access a certain resource. It only needs to be initialized.

The implementation of semaphore in Java is Semaphore, which is passed in an integer during initialization to specify the maximum concurrent access to synchronization resources

public class SemaphoreExample {
 private static Semaphore semaphore = new Semaphore(2);
 private String lock = "lock";
 private static int count = 0;
 static class MyThread extends Thread {
  @Override
  public void run() {
   super.run();
   try {
    while (true) {
     semaphore.acquire();
     Thread.sleep(500);
     System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count++);
     semaphore.release();
     Thread.sleep(500);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread();
  MyThread thread2 = new MyThread();
  MyThread thread3 = new MyThread();
  thread1.start();
  thread2.start();
  thread3.start();
 }
}

CountDownLatch implements a waiting mechanism, such as waiting for participants to arrive before starting a conference. ConutDownLatch is a counter during initialization to specify the number to wait. In concurrent programming, the need to be solved is to wait for all threads to reach a certain point. Just start the next step, which is a bit similar to a meeting. The meeting can only start when all the participants have arrived

public class CountDownLatchExample {
 private static CountDownLatch mCountDownLatch = new CountDownLatch(3);
 static class MyThread extends Thread {
  int awaitTime;
  public MyThread(int i) {
   this.awaitTime = i;
  }
  @Override
  public void run() {
   super.run();
   try {
    while (true) {
     Thread.sleep(awaitTime);
     System.out.println(Thread.currentThread().getName() + "arrived " );
     mCountDownLatch.countDown();
     mCountDownLatch.await(); //可以指定等待时间
     System.out.println(Thread.currentThread().getName() + "start meeting " );
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread(500);
  MyThread thread2 = new MyThread(1000);
  MyThread thread3 = new MyThread(2000);
  thread1.start();
  thread2.start();
  thread3.start();
 }
}

Summary

The above is the detailed content of Example of mutex semaphore and multi-thread waiting mechanism in Java. For more information, please follow other related articles on the PHP Chinese website!