Java-CountDownLatch和Semaphore

朱雀 2022-12-28 00:44 163阅读 0赞

### 文章目录 ###

*  一、CountDownLatch
 *  二、Semaphore

--------------------

# 一、CountDownLatch #

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public CountDownLatch(int count)</td> 
   <td>参数传递线程数，表示等待线程数量</td> 
  </tr> 
  <tr> 
   <td>public void await()</td> 
   <td>让线程等待</td> 
  </tr> 
  <tr> 
   <td>public void countDown()</td> 
   <td>当前线程执行完毕</td> 
  </tr> 
 </tbody> 
</table>

使用场景：让某一条线程等待其他线程执行完毕之后再执行。

import java.util.concurrent.CountDownLatch;
    
    public class Test {
        
        public static void main(String[] args) {
        
            CountDownLatch countDownLatch = new CountDownLatch(3);
            MotherThread motherThread = new MotherThread(countDownLatch);
            motherThread.start();
    
            ChileThread1 t1 = new ChileThread1(countDownLatch);
            t1.setName("小明");
    
            ChileThread2 t2 = new ChileThread2(countDownLatch);
            t2.setName("小红");
    
            ChileThread3 t3 = new ChileThread3(countDownLatch);
            t3.setName("小刚");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }
    
    class MotherThread extends Thread {
        
        private CountDownLatch countDownLatch;
    
        public MotherThread(CountDownLatch countDownLatch) {
        
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
        
            try {
        
                countDownLatch.await();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("妈妈在收拾碗筷");
        }
    }
    
    class ChileThread1 extends Thread {
        
    
        private CountDownLatch countDownLatch;
    
        public ChileThread1(CountDownLatch countDownLatch) {
        
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
        
            for (int i = 1; i <= 10; i++) {
        
                System.out.println(getName() + "在吃第" + i + "个饺子");
            }
            countDownLatch.countDown();
        }
    }
    
    class ChileThread2 extends Thread {
        
    
        private CountDownLatch countDownLatch;
    
        public ChileThread2(CountDownLatch countDownLatch) {
        
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
        
            for (int i = 1; i <= 15; i++) {
        
                System.out.println(getName() + "在吃第" + i + "个饺子");
            }
            countDownLatch.countDown();
        }
    }
    
    class ChileThread3 extends Thread {
        
    
        private CountDownLatch countDownLatch;
    
        public ChileThread3(CountDownLatch countDownLatch) {
        
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
        
            for (int i = 1; i <= 20; i++) {
        
                System.out.println(getName() + "在吃第" + i + "个饺子");
            }
            countDownLatch.countDown();
        }
    }

> 小明在吃第1个饺子  
> 小明在吃第2个饺子  
> 小明在吃第3个饺子  
> 小明在吃第4个饺子  
> 小明在吃第5个饺子  
> 小明在吃第6个饺子  
> 小明在吃第7个饺子  
> 小明在吃第8个饺子  
> 小明在吃第9个饺子  
> 小明在吃第10个饺子  
> 小红在吃第1个饺子  
> 小红在吃第2个饺子  
> 小红在吃第3个饺子  
> 小红在吃第4个饺子  
> 小红在吃第5个饺子  
> 小红在吃第6个饺子  
> 小红在吃第7个饺子  
> 小红在吃第8个饺子  
> 小红在吃第9个饺子  
> 小红在吃第10个饺子  
> 小红在吃第11个饺子  
> 小红在吃第12个饺子  
> 小红在吃第13个饺子  
> 小红在吃第14个饺子  
> 小红在吃第15个饺子  
> 小刚在吃第1个饺子  
> 小刚在吃第2个饺子  
> 小刚在吃第3个饺子  
> 小刚在吃第4个饺子  
> 小刚在吃第5个饺子  
> 小刚在吃第6个饺子  
> 小刚在吃第7个饺子  
> 小刚在吃第8个饺子  
> 小刚在吃第9个饺子  
> 小刚在吃第10个饺子  
> 小刚在吃第11个饺子  
> 小刚在吃第12个饺子  
> 小刚在吃第13个饺子  
> 小刚在吃第14个饺子  
> 小刚在吃第15个饺子  
> 小刚在吃第16个饺子  
> 小刚在吃第17个饺子  
> 小刚在吃第18个饺子  
> 小刚在吃第19个饺子  
> 小刚在吃第20个饺子  
> 妈妈在收拾碗筷

总结 :

1.  CountDownLatch(int count)：参数写等待线程的数量。并定义了一个计数器。
2.  await()：让线程等待，当计数器为0时，会唤醒等待的线程
3.  countDown()： 线程执行完毕时调用，会将计数器-1。

# 二、Semaphore #

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acquire()</td> 
   <td>获取执行许可，如果获取成功才能执行。该方法是一个阻塞式方法，如果获取不成功则当前线程等待，直到获取成功位置；如果并发线程数没有到达指定的数量则获取成功，把并发数量-1</td> 
  </tr> 
  <tr> 
   <td>release()</td> 
   <td>释放执行许可，把并发数量+1</td> 
  </tr> 
 </tbody> 
</table>

使用场景：可以控制访问特定资源的线程数量。

实现步骤 :

1.  需要有人管理这个通道
2.  当有车进来了，发通行许可证
3.  当车出去了，收回通行许可证
4.  如果通行许可证发完了，那么其他车辆只能等着

import java.util.concurrent.Semaphore;
    
    public class Test {
        
        public static void main(String[] args) {
        
            MyRunnable mr = new MyRunnable();
    
            for (int i = 0; i < 100; i++) {
        
                new Thread(mr).start();
            }
        }
    }
    
    class MyRunnable implements Runnable {
        
        //1.获得管理员对象，
        private Semaphore semaphore = new Semaphore(2);
    
        @Override
        public void run() {
        
            //2.获得通行证
            try {
        
                semaphore.acquire();
                //3.开始行驶
                System.out.println("获得了通行证开始行驶");
                Thread.sleep(2000);
                System.out.println("归还通行证");
                //4.归还通行证
                semaphore.release();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

--------------------