Question

我正在尝试实现一个计算每个元素出现次数的频率计数器。在这种情况下，两个进程可以同时调用hfc.count（1）和hfc.count（2）。我总结了确保2000000的进程数量，但是我差不多就像~100000。

class FrequencyCounter {
HashMap<Integer, Integer> frequencyMap = new HashMap<Integer, Integer>();
int max ;

FrequencyCounter(int max) {
    this.max = max ;
    for (int i = 0; i < max; i++) {
        frequencyMap.put(i, 0);
    }
}

void count(int event) {
    synchronized (this) {
        if (frequencyMap.containsKey(event)) {
            frequencyMap.put(event, frequencyMap.get(event) + 1);
        }
    }
}

/**
 * @param event
 * @return the frequency of event since creation.
 */
int frequency(int event) {

    return frequencyMap.get(event);
}

并发频率计数器

class HighFrequencyCounter extends FrequencyCounter {

int[] count;
static int n;

/**
 * @ClassInvariant {frequencyMap != null && max > 0}
 */

HighFrequencyCounter(int max) {
    super(max);

    count = new int[max];
}

void count(int event) {
    if (count[event] != 0) {
        n++;
        super.count(event);
    }
    if (count[event] < 1) {
        count[event] = 1;
        frequencyMap.put(event, frequencyMap.get(event) + 1);
        count[event] = 0;

    }
}

public static void main(String Args[]) throws InterruptedException {

    class HEventer extends Thread {
        HighFrequencyCounter hfc;

        HEventer(HighFrequencyCounter hfc) {
            this.hfc = hfc;
        }

        public void run() {
            Random r = new Random();
            for (int i = 0; i < 20000; i++) {
                hfc.count(r.nextInt(10));
            }
        }
    }

    HighFrequencyCounter hfc = new HighFrequencyCounter(10);
    HEventer hev[] = new HEventer[1000];
    for (int i = 0; i < 1000; i++) {
        hev[i] = new HEventer(hfc);
    }

    long hstartTime = System.currentTimeMillis();
    for (int i = 0; i < 1000; i++) {
        hev[i].start();
    }
    for (int i = 0; i < 1000; i++) {
        hev[i].join();
    }
    long hendTime = System.currentTimeMillis();
    System.out.println(hendTime - hstartTime);

    int sumProcesses = 0;
    for (int i = 0; i < 10; i++) {
        System.out.println(i + " =  " + hfc.frequency(i));
        sumProcesses = sumProcesses + hfc.frequency(i);

    }
    System.out.println(sumProcesses);
    System.out.println(hfc.n);

}

}

我知道这可以使用java的并发哈希映射，但我试图同步只是简单的哈希映射。我的普通frequencyCounter类可以正常工作，但我不知道如何同步count方法。

对于高频计数器我同步了count方法，并在while内使用wait（count [event]！= 0）wait（）但是这允许并发调用，因为我需要同步count方法。

Answer 1

您需要同步frequencyMap的所有共享访问权限，不仅仅是在写信的时候。由于this上的锁被保护，因此写入地图从地图上阅读时，你需要在同一个锁上同步。

int frequency(int event) {
    synchronized (this) {
        return frequencyMap.get(event);
    }
}

没有同步，一个线程可能看不到另一个线程写的内容。这解释了你得到的不一致的价值。

顺便说一句，我注意到构造函数将映射中的初始值设置为[0..max)范围内的0。如果地图只使用此范围内的键，然后一个数组比哈希映射更合适，更轻。

正如你在评论中写道的那样：

我的问题是关于HighFrequencyCounter的计数（事件）功能。如果我想允许两个不同整数事件的线程，说hfc.count(4)和hfc.count(3)同时运行但不是两个并发调用hfc.count(3)，我使用count[0..Max]作为数组保持条件。这是我在同步中遇到困难的地方

基于此描述，你每个柜台需要一把锁。这是一个使用一个数组进行计数的简单实现，还有一个用于锁：

class FrequencyCounter {
    private final int[] counts;
    private final Object[] locks;

    FrequencyCounter(int max) {
        counts = new int[max];
        locks = new Object[max];
        IntStream.range(0, max).forEach(i -> locks[i] = new Object());
    }

    void count(int event) {
        synchronized (locks[event]) {
            counts[event]++;
        }
    }

    int frequency(int event) {
        synchronized (locks[event]) {
            return counts[event];
        }
    }
}

并发频率计数器更新java

1 个答案: