Logs Collector

import java.util.Random;

public class LogsCollectorExample {

    public static void main(String[] args) {
        final int HASHSETS_NUM = 20;

        final OpenAddressHashSet[] hashsets = new OpenAddressHashSet[HASHSETS_NUM];
        for (int i = 0; i < hashsets.length; i++) {
            hashsets[i] = new OpenAddressHashSet();
        }
        addRandomElementsToHashtables(hashsets);
        System.out.println("Added all elements to sets. Start sending them to one set");


        // Now we want to send all elements from all sets to the one big set.
        // We create iterator for each hashset.
        // In a cycle we send one element from each set to the big one until all elements are sent.
        final HashSetIterator[] iters = new HashSetIterator[hashsets.length];
        for (int i = 0; i < iters.length; i++) {
            iters[i] = new HashSetIterator(hashsets[i]);
        }

        final OpenAddressHashSet sumHashSet = new OpenAddressHashSet();
        long hasSent = 0;
        final long START_TIME = System.currentTimeMillis();
        long lastTime = START_TIME;
        while (true) {
            boolean changed = false;
            for (HashSetIterator iter : iters) {
                if (iter.hasNext()) {
                    changed = true;
                    sumHashSet.add(iter.next());
                    if (++hasSent % 30000 == 0) {
                        long currentTime = System.currentTimeMillis();
                        System.out.printf("queries sent: %dK, elements: %d, total_time: %d ms, diff_time: %d ms\n", hasSent / 1000, sumHashSet.usedCnt, currentTime - START_TIME, currentTime - lastTime);
                        lastTime = currentTime;
                    }
                }
            }
            if (!changed) {
                break;
            }
        }
        System.out.println("Done!");
    }

    private static void addRandomElementsToHashtables(OpenAddressHashSet[] hashsets) {
        final Random rnd = new Random(123);
        final int CNT_DIFFERENT_ELEMENTS = 2_000_000;
        for (int i = 0; i < CNT_DIFFERENT_ELEMENTS; i++) {
            long value = rnd.nextLong();
            int cntHashSets = rnd.nextInt(10);
            for (int j = 0; j < cntHashSets; j++) {
                int hashsetId = rnd.nextInt(hashsets.length);
                hashsets[hashsetId].add(value);
            }
        }
    }

    static class OpenAddressHashSet {
        private long[] values;
        private boolean[] used;
        int usedCnt;

        OpenAddressHashSet() {
            init(10);
        }

        public void add(long x) {
            needResize();
            int pos = getHashCode(x);
            while (used[pos]) {
                if (values[pos] == x) {
                    return;
                }
                pos = next(pos);
            }
            used[pos] = true;
            values[pos] = x;
            usedCnt++;
        }

        private void needResize() {
            if (usedCnt * 2 > values.length) {
                boolean[] oldUsed = used;
                long[] oldValues = values;
                init((int) Math.max(10, values.length * 5L / 3));
                for (int i = 0; i < oldUsed.length; i++) {
                    if (oldUsed[i]) {
                        add(oldValues[i]);
                    }
                }
            }
        }

        private int next(int x) {
            return x == values.length - 1 ? 0 : (x + 1);
        }

        private int getHashCode(long x) {
            final long MAGIC = 3452352354234535423L; // just some random odd number
            int pos = (int) (x * MAGIC % values.length);
            if (pos < 0) {
                pos += values.length;
            }
            return pos;
        }

        private void init(int size) {
            values = new long[size];
            used = new boolean[size];
            usedCnt = 0;
        }
    }

    static class HashSetIterator {
        private int iter;
        private OpenAddressHashSet hashSet;

        HashSetIterator(OpenAddressHashSet hashSet) {
            this.hashSet = hashSet;
            iter = -1;
            goToNextElement();
        }

        public boolean hasNext() {
            return iter != hashSet.values.length;
        }

        public long next() {
            if (iter == hashSet.values.length) {
                throw new AssertionError("no more elements");
            }
            long result = hashSet.values[iter];
            goToNextElement();
            return result;
        }

        private void goToNextElement() {
            iter++;
            while (iter != hashSet.values.length) {
                if (hashSet.used[iter]) {
                    break;
                }
                iter++;
            }
        }
    }
}