Classe parent abstraite ObjectPool
Copiez le code comme suit :
importer java.util.Iterator ;
importer java.util.Vector ;
classe abstraite publique ObjectPool<T> {
private Vector<T> verrouillé, déverrouillé ; // verrouillé est la collection d'objets occupés, déverrouillé est la collection d'objets disponibles
pool d'objets public() {
verrouillé = new Vector<T>();
déverrouillé = new Vector<T>();
}
//Créer un objet
résumé protégé T create();
//Vérifier la validité de l'objet
public abstract boolean validate(T o);
// Invalide l'objet
public abstract void expire(T o);
// Extraire : récupérer l'objet du pool d'objets
public synchronisé T checkOut() {
Tt;
si (unlocked.size() > 0) {
Itérateur<T> iter = unlocked.iterator();
while(iter.hasNext()) {
t = iter.next();
if(validate(t)) { // L'objet est valide
déverrouillé.remove(t);
verrouillé.add(t);
retourner t ;
}
else { // L'objet a expiré
déverrouillé.remove(t);
expirer(t);
}
}
}
// Il n'y a aucun objet disponible dans le bassin d'objets, créez un nouvel objet
t = créer();
verrouillé.add(t);
retour(t);
}
// Archiver : relâcher l'objet dans le pool d'objets
enregistrement d'annulation synchronisé public (T t) {
verrouillé.remove(t);
if(validate(t)) { // Si l'objet est toujours valide, remettez-le dans la collection d'objets disponible
déverrouillé.add(t);
}
else { // Sinon, invalide l'objet
expirer(t);
}
}
}
Sous-classe JDBCConnectionPool
Copiez le code comme suit :
importer java.sql.Connection ;
importer java.sql.DriverManager ;
importer java.sql.SQLException ;
la classe publique JDBCConnectionPool étend ObjectPool<Connection> {
URL de chaîne privée, usr, pwd ;
public JDBCConnectionPool (pilote de chaîne, URL de chaîne, usr de chaîne, mot de passe de chaîne) {
super();
//Charger le pilote de base de données correspondant
essayer {
Class.forName(driver).newInstance();
}
capture (Exception e) {
e.printStackTrace();
}
this.url = url ;
this.usr = usr;
this.pwd = pwd;
}
@Outrepasser
Connexion protégée créer() {
essayer {
return DriverManager.getConnection(url, usr, pwd);
}
catch (SQLException e) {
e.printStackTrace();
}
renvoie null ;
}
@Outrepasser
validation booléenne publique (Connexion o) {
essayer {
return o.isClosed();
}
catch (SQLException e) {
e.printStackTrace();
}
renvoie faux ;
}
@Outrepasser
public void expire (Connexion o) {
essayer {
o.close();
}
catch (SQLException e) {
e.printStackTrace();
}
enfin {
o = nul ;
}
}
public static void main (String[] arguments) {
JDBCConnectionPool dbConnPool = new JDBCConnectionPool("com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1:3306/test", "root", "123");
// Récupère l'objet de connexion à la base de données
Connexion conn = dbConnPool.checkOut();
//Utiliser l'objet de connexion à la base de données
//...
// Libère l'objet de connexion à la base de données
dbConnPool.checkIn(conn);
}
}
Copiez le code comme suit :
classe Piscine {
privé statique final MAX_AVAILABLE = 100 ;
Sémaphore final privé disponible = nouveau Sémaphore (MAX_AVAILABLE, true) ;
L'objet public getItem() lance InterruptedException {
disponible.acquérir();
return getNextAvailableItem();
}
public void putItem (Objet x) {
si (markAsUnused(x))
disponible.release();
}
// Pas une structure de données particulièrement efficace juste pour la démo ;
protected Object[] items = ... quels que soient les types d'éléments gérés
protected boolean[] used = new boolean[MAX_AVAILABLE];
Objet synchronisé protégé getNextAvailableItem() {
pour (int je = 0; je < MAX_AVAILABLE; ++i) {
si (!utilisé[i]) {
utilisé[i] = vrai;
retourner les articles[i] ;
}
}
renvoie null ; // non atteint
}
protégé synchronisé booléen markAsUnused (élément d'objet) {
pour (int je = 0; je < MAX_AVAILABLE; ++i) {
si (élément == éléments[i]) {
si (utilisé[i]) {
utilisé[i] = faux;
renvoie vrai ;
} autre
renvoie faux ;
}
}
renvoie faux ;
}
}