Méthode d'implémentation du pool de fils d'écriture Java

Cet exemple partage le code d'implémentation du pool de threads manuscrit Java pour votre référence. Le contenu spécifique est le suivant

1. Le pool de threads est une forme de multi-threading. Pendant le traitement, des tâches sont ajoutées à la file d'attente, puis ces tâches sont automatiquement démarrées après la création du thread. Les threads de filetage sont tous des threads d'arrière-plan.

2. Architecture de piscine simple

3. Code de pool de thread simple (auto-optimisation)

 Importer java.util.list; / ** * Interface thread * * @author yjian * @date 14:49 2017/10/14 ** / interface publique iTHReadpool {// Ajouter la tâche void execute (tâche Runnable); // Ajouter des tâches de tâche void EXECUTE (Tâches Runnable []); // Ajouter des tâches de tâche void EXECUTE (list <NICKABLE>); // détruire le thread void détruire ();}

 Importer java.util.linkedlist; import java.util.list; import java.util.concurrent.atomic.atomic. ITHReadpool {// Le nombre de threads est activé par défaut static int worker_number = 5; // Le nombre de threads terminés est statique volatile int sumcount = 0; // La liste des files d'attente des tâches n'est pas thread-safe et peut être optimisée pour BlockingQueue STATIC LIST <SORNABLE> taskQueue = new LinkedList <Scandable> (); // Thread WorkGroup WorkerThread [] WorkThreads; // atomique statique atomiclong threadnum = new atomiclong (); ThreadPoolImpl statique Threadpool; // Méthode de construction publique ThreadPoolImpl () {this (worker_number); } public threadpoolIMPl (int workernum) {this.worker_number = workernum; // Développement de Work Thread Space Workthreads = new WorkerThread [Worker_Number]; // Démarrer Créer un thread de travail pour (int i = 0; i <worker_number; i ++) {workthreads [i] = new WorkerThread (); Thread thread = new Thread (workthreads [i], "Threadpool-worker" + threadnum.incrementandget ()); System.out.println ("Initialiser le nombre de threads" + (i + 1) + "----------- Nom du thread actuel:" + Thread.getName ()); thread.start (); }} @Override public String toString () {return "Le nombre de threads de travail est" + wearch_number + "Nombre de tâches terminées" + sumcount + "nombre de tâches d'attente" + taskqueue.size (); } // Get Thread Pool public static ithReadpool getThreadpool () {return getThreadpool (worker_number); } public static ithReadpool getThreadpool (int workernum) {// tolérance de défaut, si moins ou égal à 0, le nombre par défaut de threads est if (workernum <= 0) {workernum = worker_number; } if (threadpool == null) {threadpool = new ThreadPoolImpl (workernum); } return threadpool; } @Override public void execute (runnable tâche) {synchronisé (taskqueue) {taskQueue.add (tâche); taskQueue.NotifyAll (); }} @Override public void execute (runnable [] tâches) {synchronisé (taskQueue) {for (runnable task: tasks) {taskqueue.add (tâche); } taskqueue.notifyall (); }} @Override public void Execute (list <Runnable> tâches) {synchronisé (taskQueue) {for (runnable task: tasks) {taskqueue.add (tâche); } taskqueue.notifyall (); }} @Override public void destrust () {// Où est une tâche encore présente dans la boucle, s'il y a 20 millisecondes en attente de temps de traitement pendant (! Taskqueue.isempty ()) {try {Thread.Sleep (20); } catch (InterruptedException e) {e.printStackTrace (); }} // Si la file d'attente de tâche a été traitée, détruisez le thread et effacez la tâche pour (int i = 0; i <worker_number; i ++) {workthreads [i] .setworkerFlag (); WorkThreads [i] = null; } threadpool = null; taskqueue.clear (); } // Créer un thread de travail Classe de pool WorkerThread étend Thread {// Utiliser pour identifier le thread actuel appartient à l'état actif State privé booléen isrunning = true; @Override public void run () {runnable runnable = null; // ne jamais boucle while (isrunning) {// non thread-saa, donc synchronisé (taskqueue) {while (Isrunning && taskqueue.isempty ()) {try {// Si la file d'attente de tâche est vide, attendez la tâche d'écoute de 20 millisecondes pour atteindre taskqueue.wait (20); } catch (exception e) {e.printStackTrace (); }} // La file d'attente de tâche n'est pas vide if (! Taskqueue.isempty ()) {runnable = taskqueue.remove (0); // Obtenez la première tâche}} if (runnable! = Null) {runnable.run (); } sumCount ++; runnable = null; }} // détruire le thread public void setworkerflag () {Isrunning = false; }}}

 import java.util.arraylist; import java.util.list; / ** * classe de test * * @author yjian * @date 15:37 2017/10/14 ** / classe publique ThreadPoolTest {public static void Main (String [] args) {// get Thread Pool itHreadpool t = ThreadPoollThgetThreadPool (20); List <runnable> taskList = new ArrayList <Scandable> (); for (int i = 0; i <100; i ++) {taskList.add (new task ()); } // Exécuter la tâche T.Execute (TaskList); System.out.println (t); // détruire le thread t.destroy (); System.out.println (t); } La tâche de classe statique implémente Runnable {private statique volatile int i = 1; @Override public void run () {System.out.println ("Thread actuellement traité:" + thread.currentThread (). GetName () + "Exécuter la tâche" + (i ++) + "complet"); }}}

Après avoir étudié le code source de ressort, vérifiez soigneusement quels modèles couramment utilisés sont utilisés par le code. Les spécifications pour les programmes d'écriture devraient être les mêmes que le printemps.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.