這篇文章主要介紹了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中文網其他相關文章！
