1. Semaphore
Parlons d'abord du sémaphore. Le sémaphore peut contrôler le nombre de ressources accessibles simultanément, obtenir une licence via acquire (), attendez s'il y a non et release () publie une licence. Il est généralement utilisé pour contrôler le nombre de threads simultanés et l'exclusion mutuelle entre les threads. De plus, le reentrantlock peut également implémenter cette fonction, mais l'implémentation est plus compliquée.
La fonction est similaire aux 5 fosses des toilettes. Si 10 personnes doivent aller aux toilettes, alors combien de personnes ne peuvent aller aux toilettes qu'en même temps? En même temps, seulement 5 personnes peuvent l'occuper. Lorsque l'une des cinq personnes s'éloigne, l'une des 5 autres personnes qui attendent peuvent l'occuper. De plus, parmi les 5 personnes en attente, ils peuvent obtenir des opportunités prioritaires au hasard, ou ils peuvent obtenir des opportunités par ordre d'abord, puis arriver.
Un seul objet Semaphore peut implémenter la fonction d'un mutex, et il peut être obtenu par un thread et libéré par un autre thread. Cela peut être appliqué dans certains cas de récupération de blocage.
exemple:
/ ** * @description: * @param @param args * @return void return type * / public static void main (string [] args) {// thread pool exécutorService exec = exécutors.newcachedThreadpool (); // Seuls 5 threads peuvent accéder à Semaphore final SEMP = nouveau sémaphore (5); // simule 20 Accès client pour (int index = 0; index <20; index ++) {final int no = index; Runnable run = new runnable () {public void run () {try {// obtenir la permission semp.acquire (); System.out.println ("Get Accessing:" + No); Thread.Sleep ((long) (math.random () * 10000)); // Après avoir accédé, libérez Semp.Release (); System.out.println ("reste signals----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Résultat de sortie (réfléchissez à la raison pour laquelle il sortira comme ceci):
Obtenir l'accès: 1 Obtenir l'accès: 5 Obtenir l'accès: 2 Obtenir l'accès: 3 Obtenir l'accès: 0 Reste disponible Signal ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 13 signaux restables ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2. Utilisez le tuyau comme pont entre les filetages
Le tuyau a un canal source et un canal d'évier. Les données seront écrites sur le canal d'évier et lues à partir du canal source. Un en et un. Apprenons d'abord à l'utiliser.
Il convient de noter que sous java.nio.channels, cette classe indique que la méthode de communication des données de la méthode NIO est utilisée, alors utilisez un tampon pour tamponner les données.
Illustration du principe du tuyau:
Le tuyau est un tuyau vide. Une extrémité de ce tuyau vide peut être lu de l'intérieur du tuyau et l'autre extrémité peut être écrite dans le tuyau.
Processus de fonctionnement:
1. Premièrement, il doit y avoir un objet pour l'écrire dans ce tube vide. Où écrire? Ce tuyau vide a un peu d'espace, juste dans ce tuyau.
Lors de l'écriture, il est écrit dans l'espace contenu dans le tuyau lui-même. Cette taille d'espace est de 1024 octets.
2. Ensuite, un autre objet peut lire le contenu de ce tube rempli.
Sur le code
Package com.jx.test; Importer java.io.ioException; import java.nio.bytebuffer; import java.nio.channels.pipe; classe publique testpipe {/ ** * @description: * @param @param args * @return void return type * @throws ioexception * / public static void main Pipeline Pipe Pipe = Pipe.Open (); final tuy {System.out.println ("Send ......"); // Créez un thread et utilisez le port d'écriture du tuyau Pipe.SinkChannel Type PSIC Pour écrire le contenu du bytebuffer spécifié dans le pipeline int res = psic.write (bytebuffer .wrap ("bonjour, tuy res);} catch (exception e) {e.printStackTrace ();}}}; thread tpreader = new Thread () {public void run () {int bbufferSize = 1024 * 2; bytebuffer bbuffer = bytebuffer.AllOcy (bbuffeSize); try {system.out.println ("revire..."); du pipeline Pipe.SourceChannel PSOC pour lire le contenu dans le pipeline dans le bytebuffer spécifié int res = psoc.read (bbuffer); // les données ne sont pas System.out.println ("Recive Size:" Res + "Contenu:" + bytebuffertostring (bbuffer));} catch (exception e) gens Content.ReMinging ())) {System.out.println ("n'existe pas ou le contenu est vide!"); return null;} int tententsize = contenu.limit () - contenu.reminging (); stringBuffer Resultstr = new StringBuffer (); pour (int i = 0; i <Contensize; i + = 2) {Resultstr.AppEnd (Content.get.get (i)); resultstr.toString ();}}Résumer
Ce qui précède concerne les exemples de la programmation Java de la communication et du code de sémaphore dans cet article, 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!