Java中互斥鎖信號量與多執行緒等待機制的範例

這篇文章主要介紹了Java程式設計中的互斥鎖,信號量和多執行緒等待機制實例詳解，簡單介紹了互斥鎖和信號量的區別，需要的朋友可以了解下。

互斥鎖和信號量都是作業系統中為並發程式設計設計基本概念，互斥鎖和信號量的概念上的不同在於，對於同一個資源，互斥鎖只有0和1 的概念，而信號量不只如此。也就是說，信號量可以使資源同時被多個執行緒訪問，而互斥鎖同時只能被一個執行緒存取
互斥鎖在java中的實作就是ReetranLock , 在存取一個同步資源時，它的物件需要透過方法tryLock() 取得這個鎖，如果失敗，回傳false，成功回傳true。根據傳回的資訊來判斷是否要存取這個被同步的資源。看下面的例子

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();
 }
}

信號量相當於一個計數器，如果執行緒想要存取某個資源，則先要取得這個資源的訊號量，並且訊號量內部的計數器減1 ，信號量內部的計數器大於0則表示有可以使用的資源,當執行緒使用完某個資源時，必須釋放這個資源的信號量。信號量的一個作用就是可以實作指定個執行緒去同事存取某個資源。只需要在初始化 。

信號量在Java中的實作是Semaphore  ，其在初始化時傳入一個整數數， 用來指定同步資源最大的同時存取量

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 實作一個等待機制，在等待與會者到達後，開始會議的使用中。 ConutDownLatch 在初始化中一個計數器，用來指定需要等待的個數。在並發程式設計中，所解決的需求就是，等待所有的執行緒到達某個點後。才開始進行下一步，有點類似開會，只有當所有的與會人員都到齊後，會議才能開始

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();
 }
}

總結

以上是Java中互斥鎖信號量與多執行緒等待機制的範例的詳細內容。更多資訊請關注PHP中文網其他相關文章！