Multithreaded passend zur [Java] Vorlage

Einführung

Verwenden Sie Multithreading für eine ähnliche zeitaufwändige Verarbeitung, z. B. Stapelverarbeitung. Es gibt Zeiten, in denen Sie Zeit sparen möchten.

Zum Beispiel, um zu vereinfachen und zu denken Betrachten Sie die Verarbeitung von 10 Dingen, die 5 Minuten pro Prozess dauern. Ein Thread dauert 5 * 10 = 50 Minuten, Ich habe das Gefühl, dass 10 Threads in 5 Minuten fertig sind.

In einem solchen Fall ist das Schreiben mit thread-sicherer Verarbeitung Es ist ein ziemlicher Schmerz. Ab dem nächsten Mal, um die psychische Belastung in ähnlichen Situationen zu verringern Ich habe es geschrieben, weil ich so etwas wie eine Form schaffen wollte.

Implementierungsbeispiel

Derzeit ist dies ein grobes Framework, mit dem Sie threadsicher schreiben können. Ich werde alles weglassen, außer den Informationen, die ich will Wenn Sie Ihre eigene notwendige Verarbeitung einbetten, Ich stelle mir eine "Form" vor, die fertig zu sein scheint.

MultiThreadExecute.java

/**
*Multithread-Klasse
*Erstellen Sie hier einen Thread und führen Sie ihn aus
*/
public class MultiThreadExecute {
	public static void main(String[] args) {
		MultiThreadExecute logic = new MultiThreadExecute();
		int status = logic.run();
	}

	/**Anzahl der erstellten Threads*/
	private static const THREAD_COUNT = 5;
	
	protected int run() {
	
		//Erfassung der zu verarbeitenden Daten
		int dataSize = ...(Kürzung)...;
		
		//Parallele Ausführungsverarbeitung
		//Erhöhen Sie den Bereich um die Anzahl der Threads, um die Terminierungsverarbeitung einzuschließen
		final BlockingQueue<DataDto> taskQueue =
            new LinkedBlockingQueue<DataDto>(dataSize + THREAD_COUNT);
            
		//Zur Warteschlange hinzufügen
		for (DataDto data : (Kürzung. Komm von irgendwoher)) {
			taskQueue.add(data);
		}
		
		final OnExecListener listener = new OnExecListener();
		final ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            //Stellen Sie sicher, dass Sie das Ende kennen
            taskQueue.add(Legen Sie ein leeres DataDto usw.);

            //Ausführung von untergeordneten Threads
            final LogicTask task = new LogicTask(taskQueue, listener);
            executor.execute(task);
        }

		//Warten Sie, bis der Thread beendet ist
        executor.shutdown();
        while (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
        }
		
		//Erhalten Sie die Anzahl der Verarbeitung usw. wie folgt
		// listener.getTotalCount()
	}
}

DataDto.java

public class DataDto {
	//Speichert die Argumente, die zur Verarbeitung übergeben werden sollen
}

Listener.java

/**
 *Verarbeitungsendeerkennung
 */
private static interface Listener {
	/**
	*Entwerfen und erstellen Sie die gewünschten Informationen nach der Verarbeitung
	*Indem Sie die Schnittstelle genau definieren,
	*Reagieren Sie flexibel auf die gewünschten Informationen
	*/
	void execute();
}

OnExecListener.java

/**
 *Ende der Verarbeitung des Listeners
 */
private static class OnExecListener implements Listener {

	private int totalCount = 0;

    @Override
    public void execute(){
        synchronized (this) {
            totalCount++;
        }
    }

    synchronized int getTotalCount() {
        return totalCount;
    }
}

LogicTask.java

private static class LogicTask implements Runnable {
	private final BlockingQueue<DataDto> taskQueue;
	private final Listener listener;
	
	/**
	*Konstrukteur
	*/
	LogicTask(BlockingQueue<DataDto> taskQueue, Listener listener) {
		this.taskQueue = taskQueue;
		this.listener = listener;
	}

	/**
	*Eine Aufgabe ausführen
	*/
	@Override
	public void run() {
		try {
		    while (true) {
		        if (Urteil beenden) {
		            break;
		        }
		        
		        final DataDto data = taskQueue.take();
		        
		        //Führen Sie eine zeitaufwändige Verarbeitung durch
		        exec(data);
		    }
		} catch (//Kürzung) {
		    //Kürzung
		}
	}
	
	private void exec(DataDto data){
		//Kürzung
		return;
	}
}

Was ich dachte

• Seien Sie vorsichtig, wenn Sie die Multithread-Verarbeitung threadsicher schreiben ――Durch Erhöhen Ihrer eigenen "Vorlage" können Sie dies nicht nur einmal tun!