1. Semafore
Hablemos primero sobre Semaphore. Semaphore puede controlar la cantidad de recursos a los que se puede acceder simultáneamente, obtener una licencia a través de adquirir (), esperar si no hay, y liberar () libera una licencia. Generalmente se usa para controlar el número de hilos concurrentes y la exclusión mutua entre hilos. Además, el Reentrantlock también puede implementar esta función, pero la implementación es más complicada.
La función es similar a las 5 pozos en el inodoro. Si 10 personas tienen que ir al baño, ¿cuántas personas solo pueden ir al baño al mismo tiempo? Al mismo tiempo, solo 5 personas pueden ocuparlo. Cuando cualquiera de las cinco personas se mueve a un lado, una de las otras 5 personas que esperan puede ocuparlo. Además, entre las 5 personas que esperan, pueden obtener oportunidades prioritarias al azar, o pueden obtener oportunidades en el orden de llegar y luego llegar.
Un solo objeto semáforo puede implementar la función de un mutex, y puede obtenerse mediante un hilo y liberado por otro hilo. Esto se puede aplicar en algunos casos de recuperación de punto muerto.
ejemplo:
/** * @Description: * @param @param args * @return void tipo de retorno */public static void main (string [] args) {// hilo de grupo eScutorService ejecut = eCEMECEMORS.NewCachedThreadPool (); // Solo 5 hilos pueden acceder a Semaphore final SEMP = nuevo Semaphore (5); // simular 20 acceso al cliente para (int index = 0; index <20; index ++) {final int no = index; Runnable run = new runnable () {public void run () {try {// Obtener permiso semp.acquire (); System.out.println ("Obtener acceso:" + no); Thread.sleep ((long) (math.random () * 10000)); // Después de acceder, libera semp.release (); System.out.println ("RESTAYABLEAVAILABLE signals----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Resultado de salida (piense por qué sale así):
Obtener acceso: 1 Obtener acceso: 5 Obtenga Acceso: 2 Obtenga Acceso: 3 Obtenga Acceso: 0 restante disponible Señal ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------- 13 señales restantes ----------------------------------------------------------- -----------------------------------------------------------
2. Use la tubería como un puente entre roscas
Pipe tiene un canal de origen y un canal de sumidero. Los datos se escribirán en el canal de sumidero y se leerán desde el canal fuente. Uno adentro y otro. Primero aprendamos a usarlo.
Vale la pena señalar que bajo java.nio.channels, esta clase indica que se utiliza el método de comunicación de datos del método NIO, por lo tanto, use un búfer para los datos del búfer.
Ilustración del principio de tubería:
La tubería es una tubería vacía. Se puede leer un extremo de esta tubería vacía desde el interior de la tubería y el otro extremo se puede escribir en la tubería.
Proceso de operación:
1. Primero, debe haber un objeto que lo escriba en este tubo vacío. ¿Dónde escribir? Esta tubería vacía tiene un poco de espacio, justo en esta tubería.
Al escribir, se escribe en el espacio contenido en la tubería misma. Este tamaño de espacio es de 1024 bytes.
2. Entonces otro objeto puede leer el contenido de este tubo relleno.
En el código
paquete com.jx.test; import java.io.ioexception; import java.nio.byteBuffer; import java.nio.channels.pipe; public class testPipe {/** * @Description: * @param @param @param * @return void return type * @throws ioexception */public static void Main (String [] tubería de tubería de tubería = pipe.open (); final pipe.sinkchannel psic = pipe.sink (); // Para escribir datos a la tubería, debe acceder al canal de sumidero Final Pipe.SourCechannel psoc = pipe.source (); // Desde leer los datos de la tubería, debe acceder a la subproceso del canal de origen tpwriter = nuevo thing () {public void Run () {Intente intente (intente intente (intente intente (intente intente (intente intente (intente intenten {System.out.println ("Enviar ......"); // Crea un hilo y usa el puerto de escritura de la tubería. res);} catch (Exception e) {E.PrintStackTrace ();}}}; Thread tPreader = new Thread () {public void run () {int bbufferSize = 1024 * 2; byteBuffer bbuffer = byteBuffer.Allocate (bbBufferSize); intit {system.out.println ("recive ..."); de la tubería de tuberías. SourCeChannel tipo PSOC para leer el contenido en la tubería en el ByteBuffer especificado int res = PSOC.Read (bbuffer); // Los datos no son sistemat.out.println ("Tamaño de recive:"+res+"contenido:"+byteBuffertostring (bbuffer));} captura (excepción e) {E.PrintStackTRace ();}}}; tpwriter.start (); tPreader.start ();}/***byteBuffer-> content.remaining ())) {System.out.println ("no existe o el contenido está vacío!"); return null;} int contentsize = content.limit () - content.remining (); stringbuffer resultados ttr = new StringBuffer (); para (int i = 0; i <Contentsize; i += 2) {Resultstr.append (content.getchar (iht;};};} ResultStr.ToString ();}}Resumir
Lo anterior tiene que ver con los ejemplos de comunicación entre subproyes de programación Java y código semáforo en este artículo, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!