Implémentation du cache limité de programmes simultanés Java
1. Classe de base de cache bordé
package cn.xf.cp.ch14; / ** * Fonction: le cache bordé implémente la classe de base * Temps: 2:20:00 PM * Fichier: BaseBoundBuffer.java * @ Administrateur de l'auteur * * @param <v> * / public class BaseBoundBuffer <v> {private final v [] buf; Int Tail privé; Private Int Head; Count int privé; Public BaseBoundedBuffer (INT CAPACITY) {// Initialisez le tableau this.buf = (v []) nouvel objet [Capacité]; } // mis dans une données, la méthode finale ne peut pas être réécrite de Doput Void Final Void (v) réécrit. Buf [Tail] = V; if (++ tail == buf.length) {tail = 0; } // insérer une méthode, montant total ++ ++ nombre; } / ** * Sortez des données * @return * / protégé Final V Dotake () {v = buf [Head]; buf [tête] = null; if (++ head == buf.length) {head = 0; } --compter; retour v; } // En jugeant le décompte, déterminez si le tableau est complet de booléen final synchronisé iSull () {return count == buf.length; } public synchronisé final booléen iSempty () {return count == 0; }}2. Déterminez les conditions préalables avant d'effectuer l'opération
Package CN.XF.CP.CH14; / ** * Fonction: Vérifiez d'abord l'insertion et obtenez d'abord les opérations des éléments, puis effectuez l'opération. La vérification ne passe pas et ne sera pas autorisée à fonctionner * Temps: 2:33:41 PM * Fichier: GrumpyBoundedBuffer.java * @ Administrateur de l'auteur * * @param <v> * / public class GrumpyBoundBuffer <v> étend BaseBoundBuffer <v> {public GrumpyBoundBuffer (int size) {super (taille); } public synchronisé void put (v v) lance une exception {// s'il s'agit d'une file d'attente complète, le nouvel élément ne peut pas être inséré if (this.isfull ()) {throw nouvelle exception ("Qule dépasse"); } this.doput (v); } // De même, si la file d'attente est vide, le nouvel élément ne peut pas être récupéré public synchronisé v prise () lève une exception {if (this.isempty ()) {throw nouvelle exception ("aucun élément dans la file d'attente"); } return this.dotake (); }}3. Atteignez un blocage simple à travers le sondage et le sommeil
Package cn.xf.cp.ch14; / ** * Fonction: Implémentez le blocage simple par le biais de sondage et de l'hibernation * Temps: 2:55:54 PM * Fichier: SleepyBoundBuffer.java * @ Administrateur de l'auteur * * @Param <v> * / public class SleepyBoundBuffer <v> Final SleepleweledBuffer = Base 2000; Public SleepyBoundedBuffer (int Capacité) {Super (capacité); } // Lorsque vous placez dans la file d'attente publique void put (v v) lance InterruptedException {while (true) {// La boucle n'est pas verrouillée ici, sinon le verrou ne sera pas libéré. Si l'hibernation n'est pas verrouillée, le sommeil est verrouillé et d'autres ne peuvent pas le faire fonctionner pendant l'hibernation. Il est impossible pour un élément de sortir synchronisé (this) {// si la file d'attente n'est pas pleine, alors mettez l'élément if (! This.isfull ()) {this.doput (v); retour; }} // sinon, dormir et sortir du processeur pour occuper thread.sleed (sleep_granularity); }} public V Take () lance InterruptedException {while (true) {// La boucle n'est pas verrouillée ici, sinon le verrou ne sera pas libéré. Si le sommeil n'est pas verrouillé, le sommeil est verrouillé et d'autres ne peuvent pas le faire fonctionner lors du sommeil. Il n'y aura jamais de nouveaux éléments à venir en synchronisé (this) {// Si la pièce du tableau est vide, les données peuvent être récupérées if (! This.isempty ()) {return this.dotake (); } // Si la file d'attente est vide, essayez de dormir pendant quelques secondes à nouveau} thread.sleep (sleep_granularity); }}}4. Fitre conditionnelle
package cn.xf.cp.ch14; / ** * Fonction: Utilisez la file d'attente de condition * Temps: 3:32:04 PM * Fichier: BounddBuffer.java * @ Administrateur de l'auteur * * @param <v> * / public BoundBuffer (Int Capacité) {Super (capacité); } / ** * Mettez les éléments de données * @param v * @throws interruptedException * / public synchronisé void put (v) lance InterruptedException {while (this.isfull ()) {// suspendre le programme ici et le verrou sera publié this.wait (); } // Si la file d'attente n'est pas pleine, le programme est éveillé et que le verrou sera retrouvé.doput (v); // L'exécution se termine et réveille d'autres files d'attente this.notifyall (); } public synchronisé v prise () lance InterruptedException {while (this.isempty ()) {this.wait (); } V v = this.dotake (); this.notifyall (); retour v; }}Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!