详解java中的互斥锁信号量和多线程等待机制

2024-07-13 10:11:21

字体：大中小

来源：转载

供稿：网友

java/175975.html">互斥锁和信号量都是操作系统中为并发编程设计基本概念，互斥锁和信号量的概念上的不同在于，对于同一个资源，互斥锁只有0和1 的概念，而信号量不止于此。也就是说，信号量可以使资源同时被多个线程访问，而互斥锁同时只能被一个线程访问
互斥锁在java/124850.html">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编程中的互斥锁,信号量和多线程等待机制实例详解的全部内容，希望对大家有所帮助。

注：相关教程知识阅读请移步到JAVA教程频道。

上一篇：详解java中的互斥锁信号量和多线程等待机制

下一篇：zookeeper watch机制的理解