詳解java中的互斥鎖信號量和多線程等待機制

更新時間：2017年09月22日 09:19:54 作者：feifeiwendao

這篇文章主要介紹了Java編程中的互斥鎖,信號量和多線程等待機制實例詳解，簡單介紹了互斥鎖和信號量的區(qū)別，需要的朋友可以了解下。

互斥鎖和信號量都是操作系統(tǒng)中為并發(fā)編程設計基本概念，互斥鎖和信號量的概念上的不同在于，對于同一個資源，互斥鎖只有0和1 的概念，而信號量不止于此。也就是說，信號量可以使資源同時被多個線程訪問，而互斥鎖同時只能被一個線程訪問
互斥鎖在java中的實現(xiàn)就是 ReetranLock , 在訪問一個同步資源時，它的對象需要通過方法 tryLock() 獲得這個鎖，如果失敗，返回 false，成功返回true。根據(jù)返回的信息來判斷是否要訪問這個被同步的資源。看下面的例子

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

信號量相當于一個計數(shù)器，如果線程想要訪問某個資源，則先要獲得這個資源的信號量，并且信號量內部的計數(shù)器減1 ，信號量內部的計數(shù)器大于0則意味著有可以使用的資源,當線程使用完某個資源時，必須釋放這個資源的信號量。信號量的一個作用就是可以實現(xiàn)指定個線程去同事訪問某個資源。只需要在初始化。

信號量在 Java中的實現(xiàn)是 Semaphore ，其在初始化時傳入一個整型數(shù)，用來指定同步資源最大的并發(fā)訪問量

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 實現(xiàn)一個等待機制，在諸如等待與會者到達后，開始會議的使用中。ConutDownLatch 在初始化中一個計數(shù)器，用來指定需要等待的個數(shù)。在并發(fā)編程中，所解決的需求就是，等待所有的線程到達某個點后。才開始進行下一步，有點類似于開會，只有當所有的與會人員都到齊后，會議才能開始

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編程中的互斥鎖,信號量和多線程等待機制實例詳解的全部內容，希望對大家有所幫助。

有興趣的朋友可以了解：Java多線程賣票實例、Java多線程并發(fā)編程(互斥鎖Reentrant Lock)等。

您可能感興趣的文章: