Classe pai abstrata ObjectPool
Copie o código do código da seguinte forma:
importar java.util.Iterator;
importar java.util.Vector;
classe abstrata pública ObjectPool<T> {
private Vector<T> bloqueado, desbloqueado; // bloqueado é a coleção de objetos ocupados, desbloqueado é a coleção de objetos disponíveis
publicObjectPool(){
bloqueado = new Vector<T>();
desbloqueado = new Vector<T>();
}
//Cria objeto
abstrato protegido T create();
//Verifica a validade do objeto
público abstrato booleano validar(T o);
//Invalida o objeto
público abstrato void expira (T o);
// Check-out: obtém o objeto do pool de objetos
público sincronizado T checkOut() {
Tt;
if (unlocked.size() > 0) {
Iterador<T> iter=unlocked.iterator();
enquanto(iter.hasNext()) {
t = iter.next();
if(validate(t)) { // O objeto é válido
desbloqueado.remove(t);
bloqueado.add(t);
retornar t;
}
else { // O objeto expirou
desbloqueado.remove(t);
expirar(t);
}
}
}
// Não há nenhum objeto disponível no lago de objetos, crie um novo objeto
t = criar();
bloqueado.add(t);
retornar(t);
}
// Check-in: Libera o objeto de volta para o pool de objetos
público sincronizado void checkIn(T t) {
bloqueado.remove(t);
if(validate(t)) { // Se o objeto ainda for válido, coloque-o de volta na coleção de objetos disponíveis
desbloqueado.add(t);
}
else { // Caso contrário invalida o objeto
expirar(t);
}
}
}
Subclasse JDBCConnectionPool
Copie o código do código da seguinte forma:
importar java.sql.Connection;
importar java.sql.DriverManager;
importar java.sql.SQLException;
classe pública JDBCConnectionPool estende ObjectPool<Connection> {
URL de string privada, usr, pwd;
public JDBCConnectionPool(String driver, String url, String usr, String pwd) {
super();
//Carrega o driver de banco de dados correspondente
tentar {
Class.forName(driver).newInstance();
}
catch(Exceção e) {
e.printStackTrace();
}
este.url = url;
isto.usr = usr;
isto.pwd = pwd;
}
@Substituir
Conexão protegida create() {
tentar {
retornar DriverManager.getConnection(url,usr,pwd);
}
catch(SQLExceptione) {
e.printStackTrace();
}
retornar nulo;
}
@Substituir
public boolean validar(Conexão o) {
tentar {
return o.isClosed();
}
catch(SQLExceptione) {
e.printStackTrace();
}
retornar falso;
}
@Substituir
public void expira (Conexão o) {
tentar {
o.fechar();
}
catch(SQLExceptione) {
e.printStackTrace();
}
finalmente {
o = nulo;
}
}
public static void main(String[] args) {
JDBCConnectionPool dbConnPool = novo JDBCConnectionPool("com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1:3306/test", "root", "123");
//Obtém o objeto de conexão com o banco de dados
Conexão conexão = dbConnPool.checkOut();
//Utiliza objeto de conexão com banco de dados
// ...
// Libera o objeto de conexão com o banco de dados
dbConnPool.checkIn(conn);
}
}
Copie o código do código da seguinte forma:
piscina de classe {
final estático privado MAX_AVAILABLE = 100;
private final Semáforo disponível = new Semáforo(MAX_AVAILABLE, true);
objeto público getItem() lança InterruptedException {
disponível.acquire();
return getNextAvailableItem();
}
public void putItem(Objeto x) {
if (markAsUnused(x))
disponível.release();
}
// Não é uma estrutura de dados particularmente eficiente apenas para demonstração;
protected Object[] items = ... quaisquer tipos de itens sendo gerenciados
booleano protegido[] usado = novo booleano[MAX_AVAILABLE];
objeto sincronizado protegido getNextAvailableItem() {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (!usado[i]) {
usado[i] = verdadeiro;
retornar itens[i];
}
}
retornar nulo; // não alcançado
}
booleano sincronizado protegido markAsUnused (Item de objeto) {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (item == itens[i]) {
if (usado[i]) {
usado[i] = falso;
retornar verdadeiro;
} outro
retornar falso;
}
}
retornar falso;
}
}