Question

下面是我的工厂代码，它启动后台线程TempScheduler -

public class TempClientFactory {

    public static IClient getInstance() {
    new TempScheduler().startScheduler();
    return ClientHolder.INSTANCE;
    }

    private static class ClientHolder {
        private static final TempClient INSTANCE = new TempClient();
    }
}

现在客户将使用上述工厂调用我们的代码。他们只会获取我们的Client实例一次，然后使用该实例在我的实现中调用read方法 -

IClient client = TempClientFactory.getInstance();
String response = client.read(userId);

以下是我的后台线程代码，它将从URL获取数据，解析它并将其存储在类变量中 -

public class TempScheduler {

    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        public void startScheduler() {
            final ScheduledFuture<?> taskHandle = scheduler.scheduleAtFixedRate(new Runnable() {
                public void run() {
                try {
                    callServers();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                }
            }, 0, 10, TimeUnit.MINUTES);
        }
    }

    // call the servers and get the data and then parse 
    // the response.
    private void callServers() {
        String url = "url";
        RestTemplate restTemplate = new RestTemplate();
        String response = restTemplate.getForObject(url, String.class);
        parseResponse(response);

    }

    // parse the response and store it in a variable
    private void parseResponse(String response) {
        //...       
        ConcurrentHashMap<String, Map<Integer, String>> primaryTables = null;

        //...

        // store the data in ClientData class variables which can be
        // used by other threads
        ClientData.setPrimaryMapping(primaryTables);
    }
}

解析来自URL的数据后，我的上述后台线程将使用其setter将结果存储在我的类ClientData中的变量中。以下是我的ClientData class。

public class ClientData {

    private static final AtomicReference<Map<String, Map<Integer, String>>> primaryMapping = new AtomicReference<>();

    public static Map<String, Map<Integer, String>> getPrimaryMapping() {
        return primaryMapping.get();
    }

    public static void setPrimaryMapping(Map<String, Map<Integer, String>> map) {
        primaryMapping.set(map);
    }
}

问题陈述： -

现在有趣的部分来了，你可以看到客户将使用上面的工厂调用我们的代码，一旦他们调用getInstance()方法，我的后台线程就会启动，这将获取数据从URL然后解析它并将其存储在类变量中。但在执行getInstance()方法后，他们会立即在我的客户端代码中调用read method。

然后我应该在我的实现代码中使用由我的后台线程设置的变量。我的read方法实现代码使用CallableTaks和future.get，因此它将自动进入下面的call方法。在下面的类中，我应该使用由我的后台线程设置的变量值。我需要使用getPrimaryMapping方法来获取下面代码中的值。

public class ClientTask implements Callable<String> {

    private String userId = null;

    public ClientTask(String userId) {
    this.userId = userId;
    }

    @Override
    public String call() throws Exception {

    //.....

    String hostname = ClientData.getPrimaryMapping("some_string").get(some_number);

    //....

    }   
}

这种方法的问题是，一旦客户第一次调用我们的工厂来获取实例，它就会启动后台线程，该后台线程将从URL获取数据并解析它并将数据存储在类变量，但它会立即调用我的实现类的read方法..

现在有可能第一次，我的后台线程仍在解析数据，但实际调用已进入call method，然后它会尝试从getPrimaryMapping获取数据方法，但它没有任何东西，对吧？为什么bcoz仍在解析数据..那么，如何在客户调用我们的代码时第一次确保解析完成后，只允许在调用方法中获取变量值。

然后第二次会很好..由于数据将在内存中，只有第一次出现问题..

有没有办法做到这一点？

Answer 1

这不是一个优雅的解决方案，但CountDownLatch可以解决这个问题：

public class ClientData {

    private static final AtomicReference<Map<String, Map<Integer, String>>> primaryMapping = new AtomicReference<>();
    private static final CountDownLatch firstSet = new CountDownLatch(1);

    public static Map<String, Map<Integer, String>> getPrimaryMapping() {

        try { firstSet.await(); } catch (Exception ignored) {}
        return primaryMapping.get();
    }

    public static void setPrimaryMapping(Map<String, Map<Integer, String>> map) {

        primaryMapping.set(map);
        firstSet.countDown();
    }
}

如果数据存在，如何从地图中获取数据？

1 个答案: