Boyutu bilinmeyen dengesiz bir Spliterator'ı yeniden dengeleyebilir misiniz?

Ben bir Streambilinmeyen numara (dosya sayısı açık olarak bilinmemektedir) uzaktan depolanan JSON dosyaları heterojen bir dizi işleme paralelleştirmek için kullanmak istiyorum . Dosyaların boyutu, dosya başına 1 JSON kaydından diğer bazı dosyalarda 100.000 kayda kadar büyük ölçüde değişebilir. Bu durumda bir JSON kaydı , dosyada bir satır olarak temsil edilen bağımsız bir JSON nesnesi anlamına gelir.

Bunun için Akışları gerçekten kullanmak istiyorum ve bu yüzden bunu uyguladım Spliterator:

public abstract class JsonStreamSpliterator<METADATA, RECORD> extends AbstractSpliterator<RECORD> {

    abstract protected JsonStreamSupport<METADATA> openInputStream(String path);

    abstract protected RECORD parse(METADATA metadata, Map<String, Object> json);

    private static final int ADDITIONAL_CHARACTERISTICS = Spliterator.IMMUTABLE | Spliterator.DISTINCT | Spliterator.NONNULL;
    private static final int MAX_BUFFER = 100;
    private final Iterator<String> paths;
    private JsonStreamSupport<METADATA> reader = null;

    public JsonStreamSpliterator(Iterator<String> paths) {
        this(Long.MAX_VALUE, ADDITIONAL_CHARACTERISTICS, paths);
    }

    private JsonStreamSpliterator(long est, int additionalCharacteristics, Iterator<String> paths) {
        super(est, additionalCharacteristics);
        this.paths = paths;
    }

    private JsonStreamSpliterator(long est, int additionalCharacteristics, Iterator<String> paths, String nextPath) {
        this(est, additionalCharacteristics, paths);
        open(nextPath);
    }

    @Override
    public boolean tryAdvance(Consumer<? super RECORD> action) {
        if(reader == null) {
            String path = takeNextPath();
            if(path != null) {
                open(path);
            }
            else {
                return false;
            }
        }
        Map<String, Object> json = reader.readJsonLine();
        if(json != null) {
            RECORD item = parse(reader.getMetadata(), json);
            action.accept(item);
            return true;
        }
        else {
            reader.close();
            reader = null;
            return tryAdvance(action);
        }
    }

    private void open(String path) {
        reader = openInputStream(path);
    }

    private String takeNextPath() {
        synchronized(paths) {
            if(paths.hasNext()) {
                return paths.next();
            }
        }
        return null;
    }

    @Override
    public Spliterator<RECORD> trySplit() {
        String nextPath = takeNextPath();
        if(nextPath != null) {
            return new JsonStreamSpliterator<METADATA,RECORD>(Long.MAX_VALUE, ADDITIONAL_CHARACTERISTICS, paths, nextPath) {
                @Override
                protected JsonStreamSupport<METADATA> openInputStream(String path) {
                    return JsonStreamSpliterator.this.openInputStream(path);
                }
                @Override
                protected RECORD parse(METADATA metaData, Map<String,Object> json) {
                    return JsonStreamSpliterator.this.parse(metaData, json);
                }
            };              
        }
        else {
            List<RECORD> records = new ArrayList<RECORD>();
            while(tryAdvance(records::add) && records.size() < MAX_BUFFER) {
                // loop
            }
            if(records.size() != 0) {
                return records.spliterator();
            }
            else {
                return null;
            }
        }
    }
}

Sahip olduğum sorun, Akış ilk başta güzel bir şekilde paralel olsa da, en sonunda en büyük dosyanın tek bir iş parçacığında işlenmeye bırakılmasıdır. Proksimal nedenin iyi belgelendiğine inanıyorum: ayırıcı "dengesiz".

Daha somut olarak, trySplityöntemin Stream.forEachyaşam döngüsünde belirli bir noktadan sonra çağrılmadığı anlaşılır , bu nedenle sonunda küçük partileri dağıtmak için ekstra mantık trySplitnadiren yürütülür.

TrySplit'ten dönen tüm ayırıcıların aynı pathsyineleyiciyi nasıl paylaştığına dikkat edin . Bunun tüm bölücülerdeki işi dengelemek için gerçekten akıllıca bir yol olduğunu düşündüm, ancak tam paralelliğe ulaşmak için yeterli değildi.

Paralel işlemenin önce dosyalar arasında ilerlemesini istiyorum ve daha sonra birkaç büyük dosya bölünmeye bırakıldığında, kalan dosyaların parçaları arasında paralellik yapmak istiyorum. elseSonunda bloğun amacı buydu trySplit.

Bu sorunun kolay / basit / kanonik bir yolu var mı?

Sizin trySplitbakılmaksızın temel dosyaların boyutuna eşit büyüklükte çıkış böler, gerektiği. Tüm dosyalara tek bir birim gibi davranmalı ve yedeklenmiş ArrayListayırıcıyı her seferinde aynı sayıda JSON nesnesi ile doldurmalısınız . Nesnelerin sayısı, bir bölmenin işlenmesi 1 ile 10 milisaniye arasında sürecek şekilde olmalıdır: 1 ms'den daha düşük ve toplu işi bir iş parçacığına teslim etme maliyetlerine yaklaşmaya başlıyorsunuz ve bundan dolayı düzensiz CPU yükü riskini almaya başlıyorsunuz çok iri taneli görevler.

Ayırıcı bir boyut tahmini bildirmek zorunda değildir ve bunu zaten doğru bir şekilde yapıyorsunuz: tahmininiz, Long.MAX_VALUE"sınırsız" anlamına gelen özel bir değerdir. Ancak, tek bir JSON nesnesine sahip, 1 büyüklüğünde partilerle sonuçlanan çok sayıda dosyanız varsa, bu durum performansınıza iki şekilde zarar verir: dosyayı açma-okuma-kapama yükü bir darboğaz haline gelebilir ve kaçmayı başarırsanız iş parçacığının ele alınmasının maliyeti bir öğenin işlenme maliyetine kıyasla önemli olabilir ve bu yine bir darboğaz oluşturur.

Ben benzer bir sorun çözme edildi Beş yıl önce, sen bir göz olabilir benim çözüm .

Fazla denemeden sonra, hala boyut tahminleriyle oynayarak ilave bir paralellik elde edemedim. Temel olarak, herhangi bir değer Long.MAX_VALUEayırıcının çok erken sonlanmasına (ve ayrılmadan) Long.MAX_VALUEneden olurken, diğer taraftan bir tahmin trySplitdönene kadar acımasızca çağrılmaya neden olur null.

Bulduğum çözüm, kaynakları bölücüler arasında paylaşmak ve kendi aralarında yeniden dengelemelerine izin vermektir.

Çalışma kodu:

public class AwsS3LineSpliterator<LINE> extends AbstractSpliterator<AwsS3LineInput<LINE>> {

    public final static class AwsS3LineInput<LINE> {
        final public S3ObjectSummary s3ObjectSummary;
        final public LINE lineItem;
        public AwsS3LineInput(S3ObjectSummary s3ObjectSummary, LINE lineItem) {
            this.s3ObjectSummary = s3ObjectSummary;
            this.lineItem = lineItem;
        }
    }

    private final class InputStreamHandler {
        final S3ObjectSummary file;
        final InputStream inputStream;
        InputStreamHandler(S3ObjectSummary file, InputStream is) {
            this.file = file;
            this.inputStream = is;
        }
    }

    private final Iterator<S3ObjectSummary> incomingFiles;

    private final Function<S3ObjectSummary, InputStream> fileOpener;

    private final Function<InputStream, LINE> lineReader;

    private final Deque<S3ObjectSummary> unopenedFiles;

    private final Deque<InputStreamHandler> openedFiles;

    private final Deque<AwsS3LineInput<LINE>> sharedBuffer;

    private final int maxBuffer;

    private AwsS3LineSpliterator(Iterator<S3ObjectSummary> incomingFiles, Function<S3ObjectSummary, InputStream> fileOpener,
            Function<InputStream, LINE> lineReader,
            Deque<S3ObjectSummary> unopenedFiles, Deque<InputStreamHandler> openedFiles, Deque<AwsS3LineInput<LINE>> sharedBuffer,
            int maxBuffer) {
        super(Long.MAX_VALUE, 0);
        this.incomingFiles = incomingFiles;
        this.fileOpener = fileOpener;
        this.lineReader = lineReader;
        this.unopenedFiles = unopenedFiles;
        this.openedFiles = openedFiles;
        this.sharedBuffer = sharedBuffer;
        this.maxBuffer = maxBuffer;
    }

    public AwsS3LineSpliterator(Iterator<S3ObjectSummary> incomingFiles, Function<S3ObjectSummary, InputStream> fileOpener, Function<InputStream, LINE> lineReader, int maxBuffer) {
        this(incomingFiles, fileOpener, lineReader, new ConcurrentLinkedDeque<>(), new ConcurrentLinkedDeque<>(), new ArrayDeque<>(maxBuffer), maxBuffer);
    }

    @Override
    public boolean tryAdvance(Consumer<? super AwsS3LineInput<LINE>> action) {
        AwsS3LineInput<LINE> lineInput;
        synchronized(sharedBuffer) {
            lineInput=sharedBuffer.poll();
        }
        if(lineInput != null) {
            action.accept(lineInput);
            return true;
        }
        InputStreamHandler handle = openedFiles.poll();
        if(handle == null) {
            S3ObjectSummary unopenedFile = unopenedFiles.poll();
            if(unopenedFile == null) {
                return false;
            }
            handle = new InputStreamHandler(unopenedFile, fileOpener.apply(unopenedFile));
        }
        for(int i=0; i < maxBuffer; ++i) {
            LINE line = lineReader.apply(handle.inputStream);
            if(line != null) {
                synchronized(sharedBuffer) {
                    sharedBuffer.add(new AwsS3LineInput<LINE>(handle.file, line));
                }
            }
            else {
                return tryAdvance(action);
            }
        }
        openedFiles.addFirst(handle);
        return tryAdvance(action);
    }

    @Override
    public Spliterator<AwsS3LineInput<LINE>> trySplit() {
        synchronized(incomingFiles) {
            if (incomingFiles.hasNext()) {
                unopenedFiles.add(incomingFiles.next());
                return new AwsS3LineSpliterator<LINE>(incomingFiles, fileOpener, lineReader, unopenedFiles, openedFiles, sharedBuffer, maxBuffer);
            } else {
                return null;
            }
        }
    }
}