Wie die API von java.util.gleichzeitige.Zukunft anstatt threads explizit in Java?

Ich habe zwei threads laufen parallel in ein java-Programm wie folgt:

// Threading
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            gpTableCount   = getGpTableCount();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}).start();

new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            hiveTableCount = getHiveTableCount();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}).start();

while(!(gpTableCount != null && gpTableCount.size() > 0 && hiveTableCount != null && hiveTableCount.size() > 0)) {
    Thread.sleep(5000);
}
// Threading

Beide haben die gleiche Funktionalität. Unten ist der code von getHiveTableCount(). Die andere Methode ist etwas anders (eine Zeile oder zwei) aus der unten ein, aber die Funktionalität bleibt die gleiche.

public Map<String, String> getHiveTableCount() throws IOException, SQLException {
    hiveDataMap     = new HashMap<String, String>();
    hiveTableErrs   = new HashMap<String, String>();
    Iterator<String> hiveIterator = filteredList.iterator();
    Connection hiveConnection = DbManager.getHiveConnection();
    PreparedStatement hive_pstmnt = null;
    String hiveExcpnMsg;
    String ssn;
    String hiveMaxUpdTms;
    Long hiveCount;
    String gpHiveRec;
    String[] hiveArray;
    String[] hiveDetails;
    String hiveQuery;
    while(hiveIterator.hasNext()) {
        gpHiveRec   = hiveIterator.next();      
        hiveArray   = gpHiveRec.split(",");     
        hiveDetails = hiveArray[1].split("\\.");
        hiveQuery   = "select '" + hiveDetails[1] + "' as TableName, count(*) as Count, source_system_name, max(xx_last_update_tms) from " + hiveArray[1] + " where source_system_name='" + hiveArray[2] + "' group by source_system_name";
        try {
            hive_pstmnt             = hiveConnection.prepareStatement(hiveQuery);
            ResultSet hiveCountRs   = hive_pstmnt.executeQuery();
            while(hiveCountRs.next()) {
                hiveCount     = hiveCountRs.getLong(2);
                ssn           = hiveCountRs.getString(3);
                hiveMaxUpdTms = hiveCountRs.getTimestamp(4).toString();
                hiveDataMap.put(hiveDetails[1] + "," + ssn, hiveCount + "," + hiveMaxUpdTms);
            }
        } catch(org.postgresql.util.PSQLException e) {
            hiveExcpnMsg = e.getMessage();
            hiveTableErrs.put(hiveDetails[1] + ": for the SSN: " + hiveArray[2], hiveExcpnMsg + "\n");
        } catch(SQLException e) {
            hiveExcpnMsg = e.getMessage();
            hiveTableErrs.put(hiveDetails[1] + ": for the SSN: " + hiveArray[2], hiveExcpnMsg + "\n");
        } catch(Exception e) {
            hiveExcpnMsg = e.getMessage();
            hiveTableErrs.put(hiveDetails[1] + ": for the SSN: " + hiveArray[2], hiveExcpnMsg + "\n");
        }
    }
    return hiveDataMap;
}

Diese zwei threads gleichzeitig ausgeführt werden. Vor kurzem habe ich online gelesen, dass:

Zukünftige Klasse repräsentiert eine Zukunft, die das Ergebnis einer asynchronen Berechnung – ein Ergebnis, das irgendwann in der Zukunft erscheinen nach den die Verarbeitung abgeschlossen ist.

Ich Verstand das Konzept theoritically, aber ich weiß nicht, wie die java.util.gleichzeitige.Zukünftige api für die gleichen oben genannten code erstellen, anstatt threads explizit. Könnte jemand lassen Sie mich wissen, wie kann ich das implementieren multi-threading auf die Methoden: getGpTableCount() & getHiveTableCount mit java.util.gleichzeitige.Zukunft-api anstelle von erstellen von threads erstellen neuer threads wie new Thread(new Runnable() ?

1 Antworten

  • Shmulik Klein
    4. Mai 2019

    Reichen Sie Ihre Aufgaben mithilfe der Runnable Schnittstelle, die nicht zulässt, dass Sie Ihre Themen, um einen Wert zurückzugeben, die am Ende der Berechnung (und Ursache Sie verwenden eine shared-variable - gpTableCount und hiveTableCount).

    Die Callable interface ist eine spätere Ergänzung, die es erlauben, Ihre Aufgaben auf einen Wert zurückgeben (in Ihrem Fall, Map<String, String>).

    Als alternative für das arbeiten mit threads direkt Die Concurrency-API stellt die ExecutorService wie eine höhere level-Objekt, das die Verwaltung der threads, die pools und die Ausführung von Aufgaben asynchron.

    Wenn bezwingend eine Aufgabe vom Typ Callable einer ExecutorService Sie erwartet haben die Aufgabe, zu produzieren, ein Wert, aber da die bezwingend Punkt und das Ende der computaion sind nicht gekoppelt, die ExecutorService zurück Future, die es erlauben Sie erhalten diesen Wert, und blockieren, wenn dieser Wert nicht verfügbar ist. Daher, Future kann verwendet werden, um die Synchronisierung zwischen verschiedenen threads.

    Als alternative zu ExecutorService Sie können auch einen Blick auf die FutureTask<V> die Umsetzung von RunnableFuture<V>:

    Diese Klasse stellt eine Basis-Implementierung von Future, mit Methoden zum starten und Abbrechen einer Berechnung, Abfrage, um zu sehen, wenn die Berechnung abgeschlossen ist, und rufen Sie das Ergebnis der Berechnung

    Ein FutureTask kann verwendet werden, um wickeln Sie ein Callable oder Runnable Objekt.