Clase padre abstracta ObjectPool
Copie el código de código de la siguiente manera:
importar java.util.Iterator;
importar java.util.Vector;
clase abstracta pública ObjectPool<T> {
Vector privado<T> bloqueado, desbloqueado // bloqueado es la colección de objetos ocupados, desbloqueado es la colección de objetos disponibles
grupo de objetos público() {
bloqueado = nuevo Vector<T>();
desbloqueado = nuevo Vector<T>();
}
//Crear objeto
resumen protegido T crear();
// Verificar la validez del objeto
validación booleana abstracta pública (T o);
// Invalidar el objeto
caducidad del vacío abstracto público (T o);
// Verificar: obtener el objeto del grupo de objetos
checkOut público sincronizado T() {
Tt;
si (desbloqueado.tamaño() > 0) {
Iterador<T> iter = desbloqueado.iterador();
mientras(iter.hasNext()) {
t = iter.siguiente();
if(validar(t)) { // El objeto es válido
desbloqueado.remove(t);
bloqueado.add(t);
devolver t;
}
else { // El objeto ha caducado
desbloqueado.remove(t);
caducar(t);
}
}
}
// No hay ningún objeto disponible en el estanque de objetos, crea un nuevo objeto
t = crear();
bloqueado.add(t);
retorno(t);
}
// Registrarse: liberar el objeto nuevamente al grupo de objetos
checkIn vacío sincronizado público (T t) {
bloqueado.remove(t);
if(validate(t)) { // Si el objeto aún es válido, vuelva a colocarlo en la colección de objetos disponible
desbloqueado.add(t);
}
else { // De lo contrario invalida el objeto
caducar(t);
}
}
}
Subclase JDBCConnectionPool
Copie el código de código de la siguiente manera:
importar java.sql.Conexión;
importar java.sql.DriverManager;
importar java.sql.SQLException;
la clase pública JDBCConnectionPool extiende ObjectPool<Conexión> {
URL de cadena privada, usr, pwd;
público JDBCConnectionPool (controlador de cadena, URL de cadena, usuario de cadena, contraseña de cadena) {
súper();
//Carga el controlador de base de datos correspondiente
intentar {
Class.forName(controlador).newInstance();
}
captura (Excepción e) {
e.printStackTrace();
}
this.url = URL;
this.usr = usr;
this.pwd = contraseña;
}
@Anular
Conexión protegida crear() {
intentar {
devolver DriverManager.getConnection(url, usuario, contraseña);
}
captura (SQLException e) {
e.printStackTrace();
}
devolver nulo;
}
@Anular
validación booleana pública (Conexión o) {
intentar {
retorno o.isClosed();
}
captura (SQLException e) {
e.printStackTrace();
}
devolver falso;
}
@Anular
caducidad del vacío público (Conexión o) {
intentar {
o.cerrar();
}
captura (SQLException e) {
e.printStackTrace();
}
finalmente {
o = nulo;
}
}
público estático vacío principal (String [] argumentos) {
JDBCConnectionPool dbConnPool = new JDBCConnectionPool("com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1:3306/test", "root", "123");
// Obtener el objeto de conexión a la base de datos
Conexión de conexión = dbConnPool.checkOut();
//Usar objeto de conexión a base de datos
//...
// Liberar el objeto de conexión de la base de datos
dbConnPool.checkIn(conexión);
}
}
Copie el código de código de la siguiente manera:
clase piscina {
final estático privado MAX_AVAILABLE = 100;
Semáforo final privado disponible = nuevo semáforo (MAX_AVAILABLE, verdadero);
objeto público getItem() lanza InterruptedException {
disponible.adquirir();
devolver getNextAvailableItem();
}
putItem vacío público (Objeto x) {
si (marcar como no utilizado (x))
disponible.liberación();
}
// No es una estructura de datos particularmente eficiente solo para demostración;
Objeto protegido[] elementos = ... cualquier tipo de elementos que se administren
booleano protegido[] usado = nuevo booleano[MAX_AVAILABLE];
Objeto sincronizado protegido getNextAvailableItem() {
para (int i = 0; i < MAX_AVAILABLE; ++i) {
si (!usado[i]) {
usado[i] = verdadero;
devolver artículos [i];
}
}
devolver nulo // no alcanzado
}
markAsUnused booleano sincronizado protegido (elemento de objeto) {
para (int i = 0; i < MAX_AVAILABLE; ++i) {
si (elemento == elementos[i]) {
si (usado[i]) {
usado[i] = falso;
devolver verdadero;
} demás
devolver falso;
}
}
devolver falso;
}
}