Question

我正在尝试实现锁定，我想在每次写入时避免读取。

我的要求是：

读取阻止，直到第一次设置了所有两个地图。
现在第二次，如果我正在更新地图，我仍然可以返回所有两个旧地图值（在所有两个地图上完成更新之前），或者它应该阻止并返回所有新的两个地图值，只要所有两张地图都进行了更新。

由于我有两张地图 - primaryMapping，secondaryMapping所以它应该返回两张更新地图的所有新值，或者它应该返回地图的所有旧值。基本上，在更新时我不想返回具有旧值的primaryMapping，secondaryMapping具有新值。它应该是一致的，要么应该返回旧值，要么在更新映射后返回新值。在我的情况下，地图的更新将在7或8个月内发生一次（非常罕见）。我正在使用Countdown Latch，它到目前为止工作正常，没有任何问题。

现在我有两个流程如下所示：对于每个流程，我都有一个URL，我们从中获取上述两个地图的数据。一般情况下，我将为这两个流都有两个映射，因此与DEVICE流相比，这两个映射流的流量值会有不同的值。

public enum FlowType {
    PROCESS, DEVICE;
}

我有一个每5分钟运行一次的后台线程，它从每个FLOW网址获取数据，并在有更新时填充这两个地图。当应用程序第一次启动时，它将更新映射，之后，它将在7-8个月后更新映射。并不意味着流映射会同时发生变化。可能有可能PROCESS映射已更改但不是DEVICE映射。

public class DataScheduler {

    private RestTemplate restTemplate = new RestTemplate();
    private static final String PROCESS_URL = "http://process_flow_url/";
    private static final String DEVICE_URL = "http://device_flow_url/";
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public void startScheduleTask() {
        scheduler.scheduleAtFixedRate(new Runnable() {
            public void run() {
                try {
                    callService();
                } catch (Exception ex) {
                    // logging exception here using logger
                }
            }
        }, 0, 5, TimeUnit.MINUTES);
    }

    public void callService() throws Exception {
        String url = null;
        Map<FlowType, String> holder = new HashMap<FlowType, String>();
        for (FlowType flow : FlowType.values()) {
            try {
                url = getURL(flow);
                String response = restTemplate.getForObject(url, String.class);
                holder.put(flow, response);
            } catch (RestClientException ex) {
                // logging exception here using logger      
            }
        }
        parseResponse(holder);
    }

    private void parseResponse(Map<FlowType, String> responses) throws Exception {
        Map<FlowType, Mapping> partitionMapper = new HashMap<FlowType, Mapping>();
        boolean update = false;

        for (Map.Entry<FlowType, String> responseEntry : responses.entrySet()) {
            FlowType flow = responseEntry.getKey();
            String response = responseEntry.getValue();

            Map<String, Map<Integer, Integer>> primaryMapping = new HashMap<>();
            Map<String, Map<Integer, Integer>> secondaryMapping = new HashMap<>();

            if (!DataUtils.isEmpty(response)) {
                try (Scanner scanner = new Scanner(response)) {
                    boolean hasProcess = Boolean.parseBoolean(scanner.nextLine().trim().substring(HAS_PROCESS_LEN));
                    if (hasProcess) {
                        update = true;

                        // some code    
                        partitionMapper.put(flow, PartitionHolder.createMapping(
                                            primaryMapping, secondaryMapping));
                    }
                }
            }
        }
        // if there is any update, then only update the mappings, otherwise not.
        if (update) {
            PartitionHolder.setMappings(partitionMapper);
        }
    }
}

如上所示，如果任何流映射已更新，它将通过调用setMappings方法更新映射。

以下是我的PartitionHolder类：

public class PartitionHolder {

    public static class Mapping {
        public final Map<String, Map<Integer, Integer>> primaryMapping;
        public final Map<String, Map<Integer, Integer>> secondaryMapping;

        public Mapping(Map<String, Map<Integer, Integer>> primaryMapping,
                Map<String, Map<Integer, Integer>> secondaryMapping) {
            this.primaryMapping = primaryMapping;
            this.secondaryMapping = secondaryMapping;
        }

        // getters here
    }

    private static final AtomicReference<Map<FlowType, Mapping>> mappingsHolder = new AtomicReference<Map<FlowType, Mapping>>();
    private static final CountDownLatch hasInitialized = new CountDownLatch(1);

    public static Mapping getFlowMapping(FlowType flowType) {
        try {
            hasInitialized.await();
            return mappingsHolder.get().get(flowType);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(e);
        }
    }

    public static void setMappings(Map<FlowType, Mapping> newMapData) {
        mappingsHolder.set(newMapData);
        hasInitialized.countDown();
    }

    public static Mapping createMapping(
            Map<String, Map<Integer, Integer>> primaryMapping,
            Map<String, Map<Integer, Integer>> secondaryMapping) {
        return new Mapping(primaryMapping, secondaryMapping);
    }
}

现在这是我在主线程中使用PartitionHolder类的方式。在一次调用中，我们将仅获取一个流的映射。在下面的代码dataKey.getFlowType()可以是PROCESS OR DEVICE。

@Override
public DataResponse call() throws Exception {
    Mapping mappings = PartitionHolder.getFlowMapping(dataKey.getFlowType());
    // use mappings object here
}

现在在我上面的代码中，您可以看到，如果任何流映射已更新，我将通过调用setMappings方法来更新映射。有两种情况可能发生：

当应用程序第一次启动时，它可以正常工作而没有任何问题，因为它将更新两个流的映射。
现在第二次，假设对于PROCESS流程，映射已经更新，但是DEVICE流程映射尚未更新，那么在这种情况下，它将通过调用setMappings方法更新整个映射，这将覆盖{{ 1}}。这种方法的问题是，对于DEVICE流程，我将在调用mappingsHolder时开始获取空映射，因为它将DEVICE映射覆盖为空映射。正确？

如何避免第二个问题？有没有更好的方法来解决这个问题，而不是使用Map和key作为FlowType？我是否需要在这里使用工厂模式来解决这个问题或任何其他更好的方法？

Answer 1

ConcurrentHashMap是线程安全且相对快速的，因此可以简化问题：

private static final ConcurrentHashMap<FlowType, Mapping> mappingsHolder = 
        new ConcurrentHashMap<FlowType, Mapping>();

public static void setMappings(FlowType flowType, Mapping newMapData) {

    mappingsHolder.put(flowType, newMapData);
    hasInitialized.countDown();
}

public static Mapping getFlowMapping(FlowType flowType) {

    try {
        hasInitialized.await();
        return mappingsHolder.get(flowType);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new IllegalStateException(e);
    }
}

那应该解决第二个问题。

Answer 2

我同意vanOekel的意见ConcurrentHashMap将有助于解决问题 - 在DataScheduler执行try (Scanner scanner = new Scanner(response))区块内的地图更新 - 如果抛出异常，那么地图将会保持不变。

添加

public static boolean isInitialized() {
  return hasInitialized.getCount() == 0;
}

方法PartitionHolder，然后修改callService以执行重试，如果映射尚未初始化（这将永远重试，或者您可以重试N次，然后使用默认数据或中止程序或第三个选项）。

public void callService() throws Exception {
    boolean doRetry = true;
    while(doRetry) {
        String url = null;
        Map<FlowType, String> holder = new HashMap<FlowType, String>();
        for (FlowType flow : FlowType.values()) {
            try {
                url = getURL(flow);
                String response = restTemplate.getForObject(url, String.class);
                holder.put(flow, response);
            } catch (RestClientException ex) {
                // logging exception here using logger      
            }
        }
        try {
            parseResponse(holder);
            doRetry = false;
        } catch(Exception e) {
            doRetry = !PartitionHolder.isInitialized();
            if(PartitionHolder.isInitialized()) {
                throw e;
            }
        }
    }
}

如何在两个流上发生写入时如何阻止读取？

2 个答案: