Análisis del código fuente del semáforo de JUC

Semaphore se usa principalmente para limitar el número de clases de herramientas que controlan la ejecución del código concurrente, y define internamente el número de ejecuciones concurrentes a través de un permiso.

 /** * Use el componente de la versión no de Fair Semaphore */public Ksemaphore (int Permits) {sync = new NonfairSync (permisos);}/** * Especifique el componente de la versión Semaphore */public ksemaphore (int permite, boolean fair) {sync = fair? NUEVO FAIRSYNC (PERMIS): Nueva nonfairsync (permisos);}

 /** AQS Subclase Definición principal Obtener bloqueo de liberación*/Sync de clase estática abstracta extiende KabstractqueedSynChronizer {privado estático final Long SerialVersionUid = 11924572100919109333; / ** * Especifique el permiso Inicializar SEMAPHORE */ SYNC (int Permits) {setState (Permits); } / ** * devuelve el permiso restante * / final int getPerMits () {return getState (); } / ** * Obtenga permiso * / final int nofairryAcquireshared (int adquirir) {for (;;) {int disponible = getState (); int restante = disponible - adquirir; // Determine el número de permisos restantes para obtener adquirir si (restante <0 || compareSetState (disponible, restante)) {// CAS de cambio de CAS Retorno restante; }}}} / ** * Lanzamiento de liberación * / Proteged Final Boolean TryreleaseShared (int Lotess) {for (;;) {int current = getState (); int next = current + lotes; if (Next <Current) {// Overflow Throw New Error ("Supero de permiso máximo excedido"); } if (compareSetState (actual, next)) {// CAS Cambio de cambio retorno verdadero; }}} Final void reducePermits (int reducciones) {// reduce los permisos para (;;) {int current = getState (); int next = corriente - reducciones; if (NEXT> Current) {// Subflow Throw New Error ("Permit Count Underflow"); } if (compareSetState (actual, next)) {return; }}}} / ** Establezca permiso a 0* / final int dreenPermits () {for (;;) {int curt = getState (); if (corriente == 0 || compareSetState (actual, 0)) {return corriente; }}}}

 /*** Llame a adquirir a la adquisición de interrupciones para obtener el permiso en respuesta a interrupción*/public void adquirir () lanza interruptedException {sync.AcquireshareRinterrumty (1);}/*** llame a adquisergumentable para obtener permiso en la interrupción no respuesta*/public void void adquirruptly () */public boolean tryacquire () {return sync.nonfairtryacquireshared (1)> = 0;}/*** Intente obtener permiso, soporte de tiempo de espera e interrupción*/public boolean tryacquire (largo tiempo de espera, tiempo de tiempo de tiempo) tira interrupt. permiso */public void adquirir (int permite) lanza interruptedException {if (permite <0) {tirar nueva ilegalArgumentException (); } sync.AcquiresharedInterruptable (Permits);}/** * Obtenga permiso que no responde a las interrupciones */public void adquirinterruptible (int lo permita) {if (permite <0) arrojar una nueva AgumentAxception (); Sync.Acquireshared (permisos);}/** * Intente obtener permiso */public boolean tryacquire (int permisos) {if (permisos <0) tirar nueva ilegalArgumentException (); return sync.nonfairtryacquireshared (permisos)> = 0;}/** * Intente apoyar el mecanismo de tiempo de espera, respaldar la adquisición de interrupciones de permiso */público booleano tryacquire (int permite, larga tiempo de tiempo, unidad de tiempo de tiempo) lanza InterrompedException {If (Permits <0) New IlleLarGumentException (); return sync.tryacquiresharednanos (permisos, unit.tonanos (timout));}

 /** * Permiso de liberación */public Void Release () {Sync.ReleasShared (1);}/** * Permiso de liberación */Public void Release (int Permits) {if (Permits <0) tirar nueva ilegalArGumentException (); sync.releasshared (permisos);}

 /** * return Permit */public int disponible para PERMITS () {return sync.getPermits ();}/** * Consumir permiso */public int DrainPermits () {return Sync.DrainPermits ();}/** * Reducir permiso de reducción */protegido Void reducción de PERMITS (int reducción) {if (if (reducción <0) showleArGumentCoption ();); sync.educePermits (reducción);}/*** Determine si es una versión justa*/public boolean isfair () {return sync instance de FairSync;}/*** return el hilo de espera en sync queue en aqs*/public final boolean Hasqueathreadthreadthreads () {return sync.hasqueedthreads ();}/*** return the these thesque en synceue Aqs*/public final int getqueuelgent longitud de getque () {return sync.getQueuelgenting ();}/***Devuelve el hilo de espera en la cola de sincron

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.