Partition einen Satz in kleinere Teilmengen und als batch-Prozess

Habe ich einen kontinuierlichen Laufenden thread in meine Anwendung besteht aus einem HashSet speichern alle Symbole, die innerhalb der Anwendung .
Wie pro das design an die Zeit, als es geschrieben wurde , innerhalb des Thread ' s, während die wahre Bedingung wird die Iteration der hashset continosly und aktualisiert die Datenbank für alle Symbole, die enthalten innen HashSet .

Des max-Symbole, die vorhanden sein könnten innerhalb der hashset wird auf rund 6000 .
Ich nicht die db mit allen 6000 Symbole auf einmal , sondern teilen Sie diese hashset in verschiedene Teilmengen von 500 Stück (12 Sets ) und führen jede Teilmenge einzeln und haben ein Gewinde Schlaf nach jeder Teilmenge für 15 Minuten , also taht ich kann reduzieren Sie den Druck auf Datenbank .

Dies ist mein code (Beispiel-code-snippet )

Wie kann ich der Partition einen Satz in kleinere Untergruppen und Prozess , ( die ich gesehen habe, die Beispiele für Aufteilungen ArrayList , TreeSet , aber nicht finden B. im Zusammenhang mit HashSet )

package com.ubsc.rewji.threads;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.PriorityBlockingQueue;

public class TaskerThread extends Thread {
    private PriorityBlockingQueue<String> priorityBlocking = new PriorityBlockingQueue<String>();
    String symbols[] = new String[] { "One", "Two", "Three", "Four" };
    Set<String> allSymbolsSet = Collections
            .synchronizedSet(new HashSet<String>(Arrays.asList(symbols)));

    public void addsymbols(String commaDelimSymbolsList) {
        if (commaDelimSymbolsList != null) {
            String[] symAr = commaDelimSymbolsList.split(",");
            for (int i = 0; i < symAr.length; i++) {
                priorityBlocking.add(symAr[i]);
            }
        }
    }

    public void run() {
        while (true) {
            try {
                while (priorityBlocking.peek() != null) {
                    String symbol = priorityBlocking.poll();
                    allSymbolsSet.add(symbol);
                }
                Iterator<String> ite = allSymbolsSet.iterator();
                System.out.println("=======================");
                while (ite.hasNext()) {
                    String symbol = ite.next();
                    if (symbol != null && symbol.trim().length() > 0) {
                        try {
                            updateDB(symbol);

                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void updateDB(String symbol) {
        System.out.println("THE SYMBOL BEING UPDATED IS" + "  " + symbol);
    }

    public static void main(String args[]) {
        TaskerThread taskThread = new TaskerThread();
        taskThread.start();

        String commaDelimSymbolsList = "ONVO,HJI,HYU,SD,F,SDF,ASA,TRET,TRE,JHG,RWE,XCX,WQE,KLJK,XCZ";
        taskThread.addsymbols(commaDelimSymbolsList);

    }

}

Das Konzept der "Druck" auf Datenbanken ist eine seltsame... DBs sind in der Regel sehr gut in der Lage, dies zu behandeln "Druck" anmutig.

InformationsquelleAutor Pawan | 2013-10-17

10

Etwas wie
```
private static final int PARTITIONS_COUNT = 12;

List<Set<Type>> theSets = new ArrayList<Set<Type>>(PARTITIONS_COUNT);
for (int i = 0; i < PARTITIONS_COUNT; i++) {
    theSets.add(new HashSet<Type>());
}

int index = 0;
for (Type object : originalSet) {
    theSets.get(index++ % PARTITIONS_COUNT).add(object);
}
```
Haben Sie jetzt partitioniert die originalSet in 12 anderen HashSets.
- Dank Amir Pashazadeh , die Zahl 12 ist nicht festgelegt , ich will nur die didvide Elemente in allsymbolSet in verschiedenen sub hashset , so dass jede Teilmenge enthält 500 Elemente
- Wahrscheinlich nicht die beste Lösung für sein problem, aber gute Idee.
- Kann ich wissen, was wäre das eine gute Idee wäre, aus eurer Sicht ??
- Siehe meine Antwort direkt unter diesem. 😉
- Pashazadeh , die Lösung, sofern Sie gut aussieht . Ich danke Ihnen sehr .
- Nur ein heads-up wird Dies tun, ein round-robin-Verteilung auf das Ergebnis gesetzt, manchmal, die Sie erhalten wollen, um zum Beispiel von einem LinkedHashSet, würde eine andere Lösung
InformationsquelleAutor Amir Pashazadeh

Mit Guave:

for (List<String> partition : Iterables.partition(yourSet, 500)) {
    //... handle partition ...
}

InformationsquelleAutor Andrey Chaschev

Können wir den folgenden Ansatz zur Aufteilung einer Menge.

Werden wir mit der Ausgabe als
[a, b]
[c, d]
[e]`

private static List<Set<String>> partitionSet(Set<String> set, int     partitionSize)
{
    List<Set<String>> list = new ArrayList<>();
    int setSize = set.size();

    Iterator iterator = set.iterator();

    while(iterator.hasNext())
    {
        Set newSet = new HashSet();
        for(int j = 0; j < partitionSize && iterator.hasNext(); j++)
        {
            String s = (String)iterator.next();
            newSet.add(s);
        }
        list.add(newSet);
    }
    return list;
}

public static void main(String[] args)
{
    Set<String> set = new HashSet<>();
    set.add("a");
    set.add("b");
    set.add("c");
    set.add("d");
    set.add("e");

    int size = 2;
    List<Set<String>> list = partitionSet(set, 2);

    for(int i = 0; i < list.size(); i++)
    {
        Set<String> s = list.get(i);
        System.out.println(s);
    }
}

InformationsquelleAutor PipoTells

0

Sehr einfache Art und Weise für Ihre tatsächliche problem wäre, ändern Sie Ihren code wie folgt:
```
Iterator<String> ite = allSymbolsSet.iterator();
System.out.println("=======================");
int i = 500;
while ((--i > 0) && ite.hasNext()) {
```
Einer Allgemeinen Methode wäre, um den iterator zu nehmen die Elemente nacheinander in eine einfache Schleife:
```
int i = 500;
while ((--i > 0) && ite.hasNext()) {
  sublist.add(ite.next());
  ite.remove();
}
```
- warum sind Sie das entfernen der Elemente aus dem Iterator ??
- Sie müssen nicht, aber wenn Sie nicht müssten Sie notieren Sie sich Ihre aktuelle position in der Liste einen anderen Weg. Das problem ist, dass der nächste Aufruf dieser code muss nicht in eine Teilliste mit der dieselbe - Elemente wieder.
InformationsquelleAutor TwoThe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.