Multithread pour s'adapter au modèle [Java]

introduction

Utilisez le multithreading pour un traitement prenant du temps similaire, tel que le traitement par lots, Il y a des moments où vous voulez gagner du temps.

Par exemple, pour simplifier et réfléchir Envisagez de traiter 10 choses qui prennent 5 minutes par processus. Un fil prend 5 * 10 = 50 minutes, Je sens que 10 fils se termineront en 5 minutes.

Dans un tel cas, l'écriture avec un traitement thread-safe est C'est assez pénible. À partir de la prochaine fois, afin de réduire le fardeau psychologique dans des situations similaires Je l'ai écrit parce que je voulais créer quelque chose comme un moule.

Exemple d'implémentation

Pour le moment, il s'agit d'un cadre approximatif qui vous permet d'écrire en toute sécurité. Je vais tout omettre sauf les informations que je veux, alors Lorsque vous intégrez votre propre traitement nécessaire, J'imagine un "moule" qui semble terminé.

MultiThreadExecute.java

/**
*Classe multi-thread
*Créez un fil ici et exécutez-le
*/
public class MultiThreadExecute {
	public static void main(String[] args) {
		MultiThreadExecute logic = new MultiThreadExecute();
		int status = logic.run();
	}

	/**Nombre de threads créés*/
	private static const THREAD_COUNT = 5;
	
	protected int run() {
	
		//Acquisition des données à traiter
		int dataSize = ...(réduction)...;
		
		//Traitement d'exécution parallèle
		//Augmentez la zone du nombre de threads pour inclure le traitement de fin
		final BlockingQueue<DataDto> taskQueue =
            new LinkedBlockingQueue<DataDto>(dataSize + THREAD_COUNT);
            
		//Ajouter à la liste
		for (DataDto data : (réduction. Viens de quelque part)) {
			taskQueue.add(data);
		}
		
		final OnExecListener listener = new OnExecListener();
		final ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            //Assurez-vous de connaître la fin
            taskQueue.add(Mettez un DataDto vide, etc.);

            //Exécution des threads enfants
            final LogicTask task = new LogicTask(taskQueue, listener);
            executor.execute(task);
        }

		//Attendre la fin du fil
        executor.shutdown();
        while (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
        }
		
		//Obtenez le nombre de traitements, etc. comme suit
		// listener.getTotalCount()
	}
}

DataDto.java

public class DataDto {
	//Stocke les arguments à transmettre pour le traitement
}

Listener.java

/**
 *Détection de fin de traitement
 */
private static interface Listener {
	/**
	*Concevez et créez les informations souhaitées après le traitement
	*En définissant exactement l'interface,
	*Soyez flexible pour répondre aux informations que vous souhaitez
	*/
	void execute();
}

OnExecListener.java

/**
 *Fin du traitement de l'auditeur
 */
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;
	
	/**
	*constructeur
	*/
	LogicTask(BlockingQueue<DataDto> taskQueue, Listener listener) {
		this.taskQueue = taskQueue;
		this.listener = listener;
	}

	/**
	*Exécuter une tâche
	*/
	@Override
	public void run() {
		try {
		    while (true) {
		        if (Fin du jugement) {
		            break;
		        }
		        
		        final DataDto data = taskQueue.take();
		        
		        //Effectuer un traitement chronophage
		        exec(data);
		    }
		} catch (//réduction) {
		    //réduction
		}
	}
	
	private void exec(DataDto data){
		//réduction
		return;
	}
}

Ce que je pensais

• Faites attention à l'écriture de traitement multi-thread en thread-safe ―― En augmentant votre propre "modèle", vous ne pouvez pas le faire une seule fois!