androidkaifa1 commented on issue #2170:
URL: https://github.com/apache/rocketmq/issues/2170#issuecomment-662197454


   @francisoliverlee 
   感谢您的回答,我知道您的意思。但是`public synchronized void registerBrokerAll()` 这段代码只是让下面这段代码
   
   ```java
    // 启动了一个定时调度的任务,让他去给 NameServer 进行注册
           // 默认 30s 发送一次
           this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
   
               @Override
               public void run() {
                   try {
                       // 将自己注册到NameServer
                       BrokerController.this.
                               registerBrokerAll(true, false, 
brokerConfig.isForceRegister());
                   } catch (Throwable e) {
                       log.error("registerBrokerAll Exception", e);
                   }
               }
           }, 1000 * 10, Math.max(10000, 
Math.min(brokerConfig.getRegisterNameServerPeriod(), 60000)), 
TimeUnit.MILLISECONDS);
   
   ```
   线程池里面的线程安全。也就是说 
,他只是保证了定时任务不同批次任务的线程安全。但是仍然无法保证定时任务同一个批次内的线程安全。比如说:某次发送心跳。Broker需要向 
10个NameServer 发送心跳。`public List<RegisterBrokerResult> 
registerBrokerAll`方法是开启10个线程去发送心跳,如果此时同时返回结果,同时修改`registerBrokerResultList`这个`ArrayList`仍然是有并发安全问题的。
   
   `public synchronized void registerBrokerAll()` 这段代码只是保证 比如说 时刻 0 和时刻 30 
。他们发送的心跳没有并发安全问题。
   
   
   MQ里面的逻辑和下面的代码逻辑类似。
   
   ```java
   package com.example.test.arraylistrocketmq;
   
   import com.google.common.collect.Lists;
   import org.junit.Test;
   
   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.ArrayBlockingQueue;
   import java.util.concurrent.CountDownLatch;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.atomic.AtomicInteger;
   
   /**
    * @author Chen
    * @version 1.0
    * @date 2020/7/20 9:20
    * @description:
    */
   public class TestChen2 {
   
   
       @Test
       public void test() throws InterruptedException {
           for (int i = 0; i < 100; i++) {
               int finalI = i;
               Thread thread = new Thread(new Runnable() {
                   @Override
                   public void run() {
                       deal(finalI);
                   }
               });
               thread.start();
   
               thread.join();
           }
       }
   
       public synchronized void deal(int index) {
           // 初始化一个List,存放每个NameServer注册结果的
           final List<RegisterBrokerResult> registerBrokerResultList =
                   Lists.newArrayList();
           // 获取 NameServer 地址列表
           List<String> nameServerAddressList = new ArrayList<>();
           for (int j = 0; j < 10; j++) {
               nameServerAddressList.add("192.168.0." + j);
           }
           AtomicInteger atomicInteger = new AtomicInteger(0);
           // 执行其他逻辑
           final CountDownLatch countDownLatch = new 
CountDownLatch(nameServerAddressList.size());
   
           BrokerFixedThreadPoolExecutor brokerOuterExecutor = new 
BrokerFixedThreadPoolExecutor(4, 10, 1, TimeUnit.MINUTES,
                   new ArrayBlockingQueue<Runnable>(32), new 
ThreadFactoryImpl("brokerOutApi_thread_", true));
   
           // 遍历NameServer 地址列表,使用线程池去注册
           for (final String namesrvAddr : nameServerAddressList) {
               brokerOuterExecutor.execute(new Runnable() {
                   @Override
                   public void run() {
                       try {
                           // 调用 registerBroker 真正执行注册
                           RegisterBrokerResult result = new 
RegisterBrokerResult();
                           result.setHaServerAddr("chen" + 
atomicInteger.getAndIncrement());
                           Thread.sleep(100);
                           if (result != null) {
                               // 注册成功结果放到一个List里去
                               registerBrokerResultList.add(result);
                           }
   
                       } catch (Exception e) {
                           System.out.println("-----------wei---------------> " 
+ index);
                           System.out.println(e);
                           System.out.println("-----------wei---------------> " 
+ index);
                       } finally {
                           // 注册完,执行 countDownLatch.countDown(); 同步计数器 -1
                           countDownLatch.countDown();
                       }
                   }
               });
           }
   
           try {
               // 等待所有 NameServer 都注册完,才返回注册结果
               countDownLatch.await(1000000, TimeUnit.MILLISECONDS);
           } catch (InterruptedException e) {
           }
   
           System.out.println(registerBrokerResultList.size());
   //        System.out.println(registerBrokerResultList);
           
System.out.println("-----------chen---------------------------------------> ");
       }
   }
   
   ```
   
   但是上面的代码无法保证线程安全。
   
   
   
   
   
   


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
[email protected]


Reply via email to