JUC怎么模拟AND型信号量
这篇文章主要介绍“JUC怎么模拟AND型信号量”，在日常操作中，相信很多人在JUC怎么模拟AND型信号量问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”JUC怎么模拟AND型信号量”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
成都创新互联是一家集网站建设,广南企业网站建设,广南品牌网站建设,网站定制,广南网站建设报价,网络营销,网络优化,广南网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
1.一个错误示例
在这里，首先解释一下，为了满足线程申请信号量不成功后将进程阻塞，并插入到对应的队列中，所以使用了ReentrantLock+Condition来实现Swait方法。废话不多说，直接上代码：
//数据定义 static Lock lock = new ReentrantLock(); static Condition condition1 = lock.newCondition(); static Condition condition2 = lock.newCondition(); public static void Swait(String id, Semaphore s1, Semaphore s2) throws InterruptedException { lock.tryLock(1, TimeUnit.SECONDS); log.info("当前的两个信号量的状态：【{},{}】", s1.availablePermits(), s2.availablePermits()); //availablePermits可获取到信号量中还剩余的值 if(s1.availablePermits() < 1 || s2.availablePermits() < 1){ if (s1.availablePermits() < 1) { log.info("线程【{}】被挂起到信号量【{}】中", id, s1); //阻塞，并插入到condition1的阻塞队列中 condition1.await(); } else { log.info("线程【{}】被挂起到信号量【{}】中", id, s2); //阻塞，并插入到condition2的阻塞队列中 condition2.await(); } log.info("被挂起的线程【{}】被唤醒执行。", id); } else { log.info("为线程【{}】分配资源！", id); s1.acquire(); s2.acquire(); } lock.unlock(); } public static void Ssignal(Semaphore s1, Semaphore s2) throws InterruptedException { log.info("线程【{}】执行了释放资源", id); lock.tryLock(1, TimeUnit.SECONDS); s1.release(); s2.release(); //唤醒等待队列中的线程 condition.signal(); lock.unlock(); }大家仔细看上面的代码，这个也是我刚开始写的代码，第一眼看似乎是没什么问题，但是里面隐藏着一个坑，在Swait方法中，调用condition1.await()，此时线程被阻塞在这一行中，但是当被别的线程(调用Ssignal)唤醒时，在被阻塞的下一行开始继续执行，但是在后续的代码里，是没有去申请信号量的，而是直接就Swait成功了，这样在执行Ssignal时就会导致信号量凭空的增加了，也就无法正确的表征系统中的资源数量了。
2.一个简单的示例
下面我们就对代码进行优化，大家可以回顾一下AND型信号量，当其因为资源不足时，需要将线程插入到第一个无法满足条件(即Si<1)的信号量对应的等待队列中，并且将程序计数器放置到Swait操作的开始处，所以我们对Swait代码进行修改如下：
public static void Swait(String id, Semaphore s1, Semaphore s2) throws InterruptedException { lock.tryLock(1, TimeUnit.SECONDS); log.info("当前的两个信号量的状态：【{},{}】", s1.availablePermits(), s2.availablePermits()); //如果申请不到，就挂起线程，并将线程插入到condition的队列中 while (s1.availablePermits() < 1 || s2.availablePermits() < 1) { if (s1.availablePermits() < 1) { log.info("线程【{}】被挂起到信号量【{}】中", id, s1); condition1.await(); } else { log.info("线程【{}】被挂起到信号量【{}】中", id, s2); condition2.await(); } log.info("被挂起的线程【{}】被唤醒执行。", id); } log.info("为线程【{}】分配资源！", id); s1.acquire(); s2.acquire(); lock.unlock(); }在上面的代码中，我们将请求的资源放到一个循环条件中，以满足将程序计数器放置到Swait操作的开始处，在每次被唤醒后都要重新判断资源是否足够，如果足够才跳出循环，否则就再次自我阻塞。
3.一个可以同时申请N个的Swait操作
如果你知道了信号量的种类数(系统中的资源类型)，其实上面的代码已经可以满足一定的需要了，只需要我们将所有的信号量写入到参数列表中即可。但是对于致力于代码的复用，这里就有些差强人意了，因此我们再次对代码进行改进，代码如下所示：
public static void Swait(String id, Semaphore... list) throws InterruptedException { lock.lock(); //如果资源不足，就挂起线程，并将线程插入到condition的队列中 while (true) { int count=0; //循环判断参数列表中信号量的可用值 for (Semaphore semaphore:list){ if(semaphore.availablePermits()>0){ count++; } } //如果资源都满足，则跳出循环，进行资源分配 if(count == list.length){ break; } log.info("线程【{}】被挂起-----", id); //将当前线程阻塞 condition1.await(); log.info("被挂起的线程【{}】被唤醒执行。", id); } log.info("为线程【{}】分配资源！", id); //分配资源 for (Semaphore semaphore:list){ semaphore.acquire(); } lock.unlock(); } public static void Ssignal(String id, Semaphore... list) throws InterruptedException { log.info("线程【{}】执行了释放资源", id); lock.tryLock(1, TimeUnit.SECONDS); //循环释放信号量 for (Semaphore semaphore:list){ semaphore.release(); } //唤醒等待队列中的线程 condition.signal(); lock.unlock(); }为此，我们将方法中的信号量列表改为可变的参数列表，这样在传参的时候就可以方便的进行了，但是也会存才一些问题，比如无法约束“借出”与“归还”的信号量的数量是否一致。并且因为信号量的数量不定，所以无法为每个信号量新建一个条件变量(Condition)，因此在上面的代码中所有的信号量公用一个条件变量，所有阻塞的线程都插入在其阻塞队列中。
4.一个完整的例子
这里我们使用一个经典的进程同步问题来演示我们使用Java模拟的AND型信号量，在这里，我们采用生产者–消费者问题来演示，完整的代码如下：
//用来保证互斥的访问临界区(缓存区) static final Semaphore mutex = new Semaphore(1); //缓冲区，最大容量为50 static Listbuffer = new ArrayList<>(); //缓冲区中还可放入的消息数量 static final Semaphore empty = new Semaphore(50); //缓冲区中的消息数量 static final Semaphore full = new Semaphore(0); //可重入锁和条件变量 static Lock lock = new ReentrantLock(); static Condition condition = lock.newCondition(); //用与辅助的简单的生成消息 static Integer count = 0; //生产者 static class Producer extends Thread { Producer(String name) { super.setName(name); } @Override public void run() { do { try { Swait(this.getName(), mutex, empty); log.info("生产了一条消息：【{}】", count); buffer.add(count++); Thread.sleep(1000); Ssignal(this.getName(), mutex, full); } catch (InterruptedException e) { log.error("生产消息时产生异常！"); } } while (true); } } //消费者 static class Consumer extends Thread { Consumer(String name) { super.setName(name); } @Override public void run() { do { try { Swait(this.getName(), mutex, full); log.info("消费了一条消息：【{}】", buffer.remove(0)); Thread.sleep(1000); Ssignal(this.getName(), mutex, empty); } catch (InterruptedException e) { log.error("消费消息时产生异常！"); } } while (true); } } public static void Swait(String id, Semaphore... list) throws InterruptedException { lock.lock(); //如果资源不足，就挂起线程，并将线程插入到condition的队列中 while (true) { int count=0; for (Semaphore semaphore:list){ if(semaphore.availablePermits()>0){ count++; } } if(count == list.length){ break; } log.info("线程【{}】被挂起", id); condition.await(); log.info("被挂起的线程【{}】被唤醒执行。", id); } log.info("为线程【{}】分配资源！", id); for (Semaphore semaphore:list){ semaphore.acquire(); } lock.unlock(); } public static void Ssignal(String id, Semaphore... list) throws InterruptedException { log.info("线程【{}】执行了释放资源", id); lock.tryLock(1, TimeUnit.SECONDS); for (Semaphore semaphore:list){ semaphore.release(); } //唤醒等待队列中的一个线程 condition.signal(); lock.unlock(); } public static void main(String[] args) { Producer p1 = new Producer("p1"); Consumer c1 = new Consumer("c1"); p1.start(); c1.start(); }
上面代码都是可以直接执行的，如果不需要使用参数列表，可以将上面的Swait方法进行替换即可(记得创建对应的条件变量)。
到此，关于“JUC怎么模拟AND型信号量”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联网站，小编会继续努力为大家带来更多实用的文章！
文章名称：JUC怎么模拟AND型信号量
网址分享：http://shouzuofang.com/article/pgiopo.html