Une brève compréhension de la différence entre les processus et les threads dans le système d'exploitation:
Processus: Chaque processus a un code indépendant et un espace de données (contexte de processus), et la commutation entre les processus aura une surcharge importante. Un processus contient des threads 1-N. (Le processus est la plus petite unité d'allocation des ressources)
Thread: Le même type de threads partage le code et l'espace de données. Chaque thread a une pile d'exécution indépendante et un compteur de programme (PC), et la surcharge de commutation de thread est petite. (Le fil est la plus petite unité de planification du processeur)
Comme un processus, les threads sont divisés en cinq étapes: création, prête, en cours d'exécution, bloquant et se terminant.
Le multi-processus signifie que le système d'exploitation peut exécuter plusieurs tâches (programmes) en même temps.
Multithreading fait référence à plusieurs flux séquentiels exécutés dans le même programme. Tout d'abord, le fonctionnement de l'épargne et du retrait de l'argent doit être fileté, et il peut y avoir de nombreux clients. Cela signifie qu'il doit y avoir plusieurs threads et plusieurs threads exploitent conjointement une banque et que le montant de la banque doit être synchronisé. Seulement en assurant la sécurité des fils.
Alors, mettons cet exemple de ce code ici. S'il y a quelque chose qui ne va pas, veuillez le signaler. Parce qu'un vieil homme a posé des questions sur ce code multithread.
Tout d'abord, la banque, la création de ce modèle d'objet.
package com.lxk.threadtest.bank; / ** * modèle bancaire, un attribut total de montant. * <p> * * @author lxk le 2017/6/26 * / banc de classe publique {/ ** * Donnez à la banque un capital de démarrage, sinon comment pouvez-vous faire des affaires. * / private int sum = 200; // Ceci n'est jamais utilisé comme celui-ci, mais c'est aussi un mécanisme de verrouillage correct: synchroniser les blocs de code. // objet obj = nouveau objet (); / ** * Économiser de l'argent * Si vous n'ajoutez pas [la fonction synchronisée - synchronisation], des problèmes de sécurité multithreads se produiront. * / public synchronisé void add (int n) {// synchronisé (obj) {sum = sum + n; try {thread.sleep (10);} catch (exception ignore) {} // Lorsque le nombre de fois de l'épargne devient plus, vous pouvez constater que les fils d'épargne sont en effet deux alternativement l'action de sauvegarde. System.out.println (thread.currentThread (). GetName () + "... sum =" + sum); //}} / ** * retirer de l'argent * si vous n'ajoutez pas [synchronisé - fonction sync], des problèmes de sécurité multithread se produiront. * / public synchronisé void réduction (int n) {if (sum - n> = 0) {sum = sum - n;} else {System.out.println ("L'argent de la banque n'est pas suffisant!");} Essayez {thread.sleep (30);} catch (exception ignore) {} // lorsque le nombre de moments d'économie est plus en train de pratiquer de l'argent de la réduction de l'argent de plus, vous pouvez en effet procéder à des étendues de l'action de plus, économiser de l'argent. System.out.println (thread.currentThread (). GetName () + "... sum =" + sum);}}Il existe deux méthodes dans le code: Enregistrer et récupérer, ces deux méthodes et un montant total, et un certain code commenté. C'est simple et facile à comprendre, à verrouillage multi-thread, exclusif et assure la synchronisation entre les fils.
Cependant, il s'agit d'une méthode peu fréquente. La méthode couramment utilisée consiste à utiliser le mot-clé synchronisé pour modifier la méthode de synchronisation.
Modèle d'objet client
Package com.lxk.threadtest.bank; / ** * Client, implémentez l'interface Runnable (), et plusieurs personnes peuvent économiser de l'argent ensemble * * @author lxk le 2017/6/26 * / classe publique Classe Client implémente Runnable {/ ** * SAVING TYPE * / static final String type_add = "Add"; / ** type de repart Banque * / Banque de banque privée; / ** * Type d'opération pour de l'argent, économise ou retrait * / type de chaîne privée; / ** * Le nombre d'opérations est théoriquement un numéro positif * / private intyme; / ** * combien de bancs, de type de chaîne, intyme, int) {this.bank = bank; this.type = type = this.s; Money;} @ Override public void run () {for (int x = 0; x <time; x ++) {if (type_add.equals (type)) {banc.add (argent);} else if (type_reduce.equals (type)) {Bank.reduce (Money);}}}}}En tant qu'objet client, comme de nombreux clients peuvent accéder à une banque en même temps, le fonctionnement de l'économie et du retrait de l'argent est mis en œuvre à l'aide de threads.
L'attribut est construit pour passer la valeur.
Méthode principale
Package com.lxk.threadtest.bank; / ** * Instance multi-thread de déposant de l'argent bancaire * <p> * [Exigences:] * La banque a un coffre-fort. * Il y a deux déposants qui déposent ou se retirent respectivement n * 100. * Objectif: y a-t-il un problème de sécurité avec ce programme? Si oui, comment le résoudre? * <p> * [Comment trouver le problème:] * 1. Effacez quels codes sont des codes multi-thread. * 2. Partagez clairement les données. * 3. Effacez les instructions dans le code multithread fonctionnant sur des données partagées. * * @author lxk le 2017/6/26 * / public class Main {public static void main (String [] args) {// une banque et plusieurs clients bancs bancs = new Bank (); int time = 10000; int. Client.type_reduce, time, argent); thread t1 = nouveau thread (c1); thread t2 = nouveau thread (c2); t1.start (); t2.start ();}}L'effet de fonctionnement réel du code ci-dessus est illustré dans la figure ci-dessous.
Si le nombre de fois de dépôt et de retrait d'argent est faible, vous pouvez voir que les deux fils ont une séquence. Par conséquent, nous avons un plus grand nombre de fois. Ensuite, nous verrons la situation comme indiqué sur la figure. Le thread 1 retire de l'argent et lorsque le thread 0 économise de l'argent, vous pouvez voir que les deux threads sont exécutés entrelacés, avec le stockage et le retrait, et il n'y a pas de modèle.
Cela garantit la synchronisation des données.
Quant à la façon d'être hors synchronisation, c'est-à-dire des phénomènes anormaux,
Vous pouvez supprimer le mot-clé synchronisé de la méthode ADD, réduire le nombre de fois et le modifier à 3 fois, et définir la valeur initiale de la somme sur 0. Rensez le code,
Vous trouverez le soi-disant phénomène asynchrone.
Le résultat de la synchronisation hors du côté droit de la figure ci-dessus est que les deux personnes sauvent 100 à chaque fois, trois fois. Le nombre total est-il obtenu? 100 200,300 400,500 600. Cela prend beaucoup de temps.
Cependant, le résultat de l'opération n'est pas
À l'heure actuelle, si vous ajoutez synchronisé à la méthode ADD, le résultat du graphique à gauche apparaîtra, ce qui est le résultat correct.
J'ai ajouté une autre méthode par souci d'existence et de retrait. Le code devient à quoi il ressemble ci-dessus.
Ce sont presque tous les exemples de synchronisation inter-thread.
J'enregistrerai brièvement le code. Lorsqu'il est utilisé, vous pouvez le retirer en quelques minutes.
Résumer
Ce qui précède est le code complet de cet article sur la simulation du problème de synchronisation multithread Java à l'aide du retrait bancaire comme exemple. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:
Exemple de programmation multithread Java
Le principe et la mise en œuvre de la minuterie de la minuterie multithread Java
Java comprend le multi-threading en vendant des billets
S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!