Varios métodos de procesamiento de sincronización y seguridad de subprocesos de springboot
Cuando se trata de algunos recursos de dominio público, a menudo ocurre el problema de que los recursos de dominio público compiten por los derechos de acceso. Al mismo tiempo, es probable que se produzcan problemas de seguridad de subprocesos durante el procesamiento de la base de datos. , como operaciones de datos, ¿consistencia, visibilidad, etc.?
En este momento, para evitar tales problemas, el enfoque general es bloquear el público* cuando un hilo llama al recurso público* (es decir, bloque de código) *** recurso.
Los siguientes son dos métodos de sincronización simples, que se presentan brevemente primero:
Nota: La sincronización es una operación que requiere mucha sobrecarga, por lo que debe minimizarse.
No es necesario sincronizar todo el método, sólo el código clave mediante bloques de código sincronizados.
1. ¿Método de sincronización?
Es decir, el método modificado utilizando la palabra clave sincronizada.
Dado que cada objeto en Java tiene un bloqueo incorporado, cuando se modifica un método usando esta palabra clave, el bloqueo incorporado protege todo el método. El bloqueo incorporado debe adquirirse antes de llamar al método; de lo contrario, el método se bloqueará.
¿Código, por ejemplo?
¿demo pública sincronizada void(){}?
Nota: la palabra clave sincronizada también puede modificar métodos estáticos, en este caso, ¿Llamar a este método estático bloqueará toda la clase?
2 ¿Bloques de código sincronizados?
Es decir, el bloque de instrucciones modificado por la palabra clave de sincronización.
¿Los bloques de declaraciones modificados con esta palabra clave se sincronizarán automáticamente agregando bloqueos integrados?
¿El código es como?
sincronizado(objeto){?
}?
o
bloquear .lock (); prueba {
System.out.println("locked"); for (int i=0; ilt; 10; i) { ?// Amplifica el tiempo requerido para el bloque de código. para completar la ejecución, para una fácil observación
System.out.println(i); intente {
System.out.println(Thread.currentThread().getName() "Hibernar para 5 segundos!" );
Thread.sleep(5000); //amplifica el tiempo que tarda el bloque de código en finalizar la ejecución para facilitar la observación
} catch (InterruptedException e ) {
e.printStackTrace();
}
}
}
}finalmente { bloquear .unlock() ;
System.out.println("Unlocked");
}12345678910111213141516
Cuando un bloque de código está bloqueado y otro hilo está bloqueado Cuando utilice un subproceso, primero debe esperar a que el subproceso anterior termine de usarlo y libere el recurso antes de poder continuar con la ejecución.
Los dos métodos anteriores son muy simples, no escribiré más, pero existen varios problemas al usar estos dos métodos: ?
(1). Cuando se incautan, otros subprocesos deben esperar a que se libere el recurso antes de ejecutarse. Esta situación es adecuada para que las operaciones de la base de datos garanticen la atomicidad de sus datos.
Cuando el recurso que se está incautando es un servicio público inmediato, sólo tiene sentido si se lo quitan en un momento determinado. Por ejemplo, el control del aire acondicionado en un servicio público. Pero todos tienen que competir por el control del aire acondicionado. si se toma de acuerdo con el método anterior, si se usa, el control del aire acondicionado se ejecutará secuencialmente de acuerdo con el momento en que se emite la solicitud, por lo que no tiene sentido. Por lo tanto, esta situación es adecuada para ejecutar solo el primer subproceso que toma el recurso y eliminar otros subprocesos solicitantes cuando el recurso está ocupado. ¿Esta situación se puede lograr de las siguientes maneras?
3.¿Semáforo y envío de paquetes?
El semáforo es un semáforo basado en conteo. Puede establecer un número total de recursos en función de este número total, y varios subprocesos compiten para obtener señales de permiso y regresan después de completar sus respectivas solicitudes. hilos, la señal será bloqueada. La ejecución continúa mientras se espera que los recursos estén disponibles.
El siguiente contenido se implementa en springboot:
@Controller public class Controller(){
Semaphore semaphore=new Semaphore(1 ?
@GetMapping("/userInfo/request")
@ResponseBody public String Resquest(){ int availablePermits=semaphore.out.println("Recurso capturado");
}else{
System.out.println("El recurso está ocupado, inténtelo de nuevo más tarde"); return "¡El recurso está ocupado!";
} intente {
semaphore.acquire(1); ?//Solicitud para ocupar un recurso
System.out.println("El recurso se está utilizando");
Thread.sleep( 30000 ); //Amplifica el tiempo de ocupación de recursos para facilitar la observación
} catch (InterruptedException e) {
e.printStackTrace();
}finalmente{
semaphore.release(1); //liberar un recurso
} return "Éxito";
}
}123456789101112131415161718192021222324252627
p>Cuando solo hay una solicitud de recurso, el efecto es el siguiente:?
Después de ejecutar el programa, la página devuelve ¿Éxito?
Cuando varios subprocesos solicitan recursos al mismo tiempo, el efecto es el siguiente:
El subproceso que obtiene primero el recurso mostrará Éxito después de 30 segundos, y luego el subproceso que solicita que el recurso regrese?
La idea general y el marco son los siguientes y se pueden modificar según sus necesidades.