Java多线程之CountDownLatch学习

Java中concurrent包中的CountDownLatch类说白了就是一个计数器,我们可以通过设置参数来进行计数,每次只能有一个线程去操作这个计数器,通过CountDown这个函数使得计数器的值减小,当计数器的值为0时,阻塞于await方法的线程才能得以执行。

例子:下面的程序中的主线程阻塞于await方法, 只有当5个线程都执行完了,主线程才能继续执行。

  1. package com.test;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.CountDownLatch;  
  5.   
  6.   
  7. public class CountDownLatchDemo {  
  8.       
  9.     private static final int N = 5;  
  10.       
  11.     private CountDownLatch waitCountDownLatch = null;  
  12.       
  13.       
  14.     public static void main(String[] args) throws InterruptedException {  
  15.           
  16.          new CountDownLatchDemo();  
  17.     }  
  18.       
  19.       
  20.     public CountDownLatchDemo() throws InterruptedException {  
  21.           
  22.         waitCountDownLatch = new CountDownLatch(N);  
  23.           
  24.         for (int i = 0; i < N; ++i) {  
  25.               
  26.             new MyThread(i).start();  
  27.         }  
  28.           
  29.         waitCountDownLatch.await();  
  30.           
  31.         System.out.println("所有线程已经执行完成");  
  32.     }  
  33.       
  34.       
  35.     class MyThread extends Thread {  
  36.           
  37.         private int id;  
  38.           
  39.         MyThread(int id) {  
  40.               
  41.             this.id = id;  
  42.         }  
  43.           
  44.         public void run() {  
  45.               
  46.             try {  
  47.                   
  48.                 System.out.println("线程 " + id + "正在执行" );  
  49.                 Thread.sleep(new Random().nextInt(2) * 1000);  
  50.             } catch (InterruptedException ex) {  
  51.                 ex.printStackTrace();  
  52.             } finally {  
  53.                   
  54.                 waitCountDownLatch.countDown();  
  55.             }  
  56.         }  
  57.     }  
  58. }  

注:CountDownLatch类中有以下几个方法

  1. void    await()  

等待,直到计数器中的值减为0。

  1. boolean await(long timeout, TimeUnit unit)  

可以自己设置超时时间,一旦超过这个时间,await线程被唤醒,如果返回true,说明计数器为0,否则,不为0。

  1. void    countDown()  

使得计数器的值减1。

  1. long    getCount()  

得到当前计数器的值。

### PPODPOGRPO 算法的区别与联系 #### Proximal Policy Optimization (PPO) Proximal Policy Optimization 是一种强化学习方法,旨在通过引入信任区域来稳定策略更新过程。该算法利用剪切函数限制新旧策略之间的差异,从而防止参数更新过大导致性能下降。PPO 结合了 TRPO 的稳定性以及简单易实现的特点,在实践中表现出良好的收敛速度和鲁棒性[^1]。 ```python def ppo_update(policy_net, old_policy_net, optimizer, states, actions, rewards): advantages = compute_advantages(states, rewards) for _ in range(update_epochs): new_log_probs = policy_net.log_prob(actions) old_log_probs = old_policy_net.log_prob(actions).detach() ratio = torch.exp(new_log_probs - old_log_probs) surr1 = ratio * advantages surr2 = torch.clamp(ratio, 1.0 - clip_param, 1.0 + clip_param) * advantages loss = -torch.min(surr1, surr2).mean() optimizer.zero_grad() loss.backward() optimizer.step() ``` #### Direct Preference Optimization (DPO) Direct Preference Optimization 则是从人类反馈中直接优化模型的行为分布,而不需要显式的奖励信号。这种方法能够更高效地利用少量高质量的人类评价数据,并且可以避免传统基于奖励塑造的方法所带来的偏差问题。DPO 使用对比损失函数训练模型以最大化所选行为序列相对于未选行为的概率比值。 ```python def dpo_loss(selected_seq_logits, unselected_seq_logits): logits_diff = selected_seq_logits - unselected_seq_logits losses = F.softplus(-logits_diff) return losses.mean() for epoch in range(num_epochs): for batch in data_loader: selected_seq_logits, unselected_seq_logits = model(batch) loss = dpo_loss(selected_seq_logits, unselected_seq_logits) optimizer.zero_grad() loss.backward() optimizer.step() ``` #### Gradient Ratio Policy Optimization (GRPO) Gradient Ratio Policy Optimization 提出了调整正负梯度系数的概念,实验结果显示这能显著提升在线环境下的表现。特别是当采用细粒度步长感知型梯度比率时(即 GRPO+PS),其效果要好于仅考虑整体比例的情况(如 GRPO+OS)。这种机制允许更加灵活地控制不同阶段的学习速率变化趋势,有助于提高最终决策质量[^2]。 ```python class GRPOTrainer: def __init__(self, ...): self.positive_coefficient = ... self.negative_coefficient = ... def update(self, positive_gradients, negative_gradients): adjusted_positive_grads = positive_gradients * self.positive_coefficient adjusted_negative_grads = negative_gradients * self.negative_coefficient final_gradients = adjusted_positive_grads - adjusted_negative_grads apply_gradients(final_gradients) ``` 综上所述,虽然三种算法都属于强化学习领域内的改进方案,但各自侧重点有所不同:PPO 关注如何平稳有效地完成单次迭代;DPO 注重从有限数量的偏好样本里提取有用信息来进行指导;GRPO 则探索了动态调节梯度权重对于加速收敛的作用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值