Cet article démontre principalement le scénario de traitement simultané de programmation Java à travers un exemple de retirant de l'argent, comme suit.
Commencez par un exemple: implémentez l'exemple de code pour un scénario de retrait du compte bancaire.
La première classe: compte.java
Catégorie de compte:
Package cn.edu.byr.test; Compte de classe publique {String AccountNo inviate Double Balance; Public Account () {} Compte public (String AccountNo, double bilan) {this.accountno = accountno; this.balance = bilan;} public inthcode () {return accountno.hashcode ();} public string getAccountNo () {return this. getBalance () {return this.balance;} public void SetBalance (double bilan) {this.balance = bilan;} public booléen équivaut (objet obj) {if (this == obj) return true; if (obj! = null && obj.getClass () = courte.class) {compte Target = (account) obj; return Target.getAccountNo (). FAUX;}} La deuxième classe: Drawthread.java
Classe de discussion de sevrage en argent:
package cn.edu.byr.test; public class dirt thread étend thread {compte privé compte; private double drawamount; public drawingread (nom de chaîne, compte de compte, double drawamount) {super (nom); this.account = compte; this.drawamount = drawamount;} public void run () {// synchronisé (compte) {if (compte.getBalance ()> drawamount) {System.out.println (getName () + "Obtenez de l'argent avec succès, crachez les billets:" + Drawamount); // essayez {// thread.sleep (1); //} // catch (InterruptedException e) {// e.printStackTrace (); //} account.setBalance (account.getBalance () - DrawAmount); System.out.println ("/ t Le solde est:" + compte.getBalance ());} else System.out.println (getName () + "Get Retrait Money Faiche, le solde est insuffisant!"); //}} public static void Main (String [] args) {Account Acct = nouveau compte ("123456", 1000); New Drawthread ("a", act, 800) .start (); new Drawthread ("b", act, 800) .start ();}} La pièce commentée dans le code ci-dessus: (1) Bloc de code de synchronisation synchronisé (2) Hibernation thread. Si (1) et (2), il existe de nombreuses possibilités pour le résultat de l'exécution, l'une des possibilités (la probabilité est petite), qui est conforme à la logique normale:
B retire avec succès de l'argent, crache de l'argent: 800.0
L'équilibre est: 200,0
Un retrait raté et le solde était insuffisant!
Il faut que B trouve d'abord la ressource de retrait de l'argent et modifie correctement le solde avant de commencer à juger le solde des utilisateurs; Cette probabilité est très petite et la plupart des opérations seront similaires aux situations suivantes:
Un retrait avec succès de l'argent et crache l'argent: 800.0
B retire avec succès de l'argent, crache de l'argent: 800.0
L'équilibre est: -600.0
L'équilibre est: 200,0
C'est évidemment illogique. D'après les résultats en cours d'exécution, nous pouvons deviner qu'un premier saisit la ressource et retire le montant, mais avant de modifier le solde, la ressource est saisie par B; Étant donné que le solde n'a pas été modifié, B voit que le solde est toujours 800 et B retire toujours le montant; Un premier exécute le solde de modification, mais ne l'imprime pas, B saisissez la ressource; B modifie l'équilibre et imprime l'équilibre, qui est -600; A imprime l'équilibre, qui est de 200;
Si (2) le thread dort, ce doit être une condition d'erreur, car A ou B libérera les ressources du CPU en raison du sommeil après avoir récupéré le montant, et le JVM appellera d'autres processus dans l'état prêt. La deuxième chose est de retirer de l'argent et de juger que le solde doit être faux.
Si (1) un bloc de code synchronisé synchronisé est ajouté, le compte est verrouillé dans le corps de la méthode de filetage; Ensuite, la logique d'exécution sera garantie à chaque fois:
Un retrait avec succès de l'argent et crache l'argent: 800.0
L'équilibre est: 200,0
B n'a pas réussi à retirer de l'argent et le solde était insuffisant!
Vous pouvez imaginer le processus d'exécution:
Un premier préempte la ressource et verrouille la classe de compte initialement dans le corps de la méthode d'exécution; commence ensuite à exécuter le bloc de code synchrone; S'il est exécuté sur un certain lien au milieu, la ressource CPU est préemptée par B; B commence à s'exécuter et verrouille la classe de compte au début. Cependant, lors de l'ajout d'un verrou, vous constaterez que le compte a été occupé par A, et il sera ajusté à un état de blocage et attendra A pour libérer la ressource; Après avoir exécuté le bloc de code synchrone, le verrouillage du compte sera publié et B continuera à exécuter; Le solde observé lors de l'exécution B est garanti pour être modifié par A et sera exécuté normalement en fonction de la logique correcte.
Résumer
Ce qui précède est tout le contenu de cet article sur l'analyse des instances de traitement simultanées multipliées de la programmation Java, et j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!