rik/jlibredis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed not useful information from the pool

Browse Source
This commit is contained in:
Jonathan Leibiusky
2010-09-07 16:31:32 -03:00
parent d3be2f629d
commit e6105efd69
2 changed files with 547 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

368
src/main/java/redis/clients/util/FixedResourcePool.java
View File

@@ -10,40 +10,40 @@ import java.util.concurrent.TimeoutException;
/** /**
* Abstract resource pool of type T. * Abstract resource pool of type T.
* *
* Needs implementation for creation, validation and destruction of the resources. * Needs implementation for creation, validation and destruction of the
* resources.
* *
* Keeps a fixed amount of resources * Keeps a fixed amount of resources
* *
* @author Luis Dario Simonassi * @author Luis Dario Simonassi
* *
* @param <T> The type of the resource to be managed. * @param <T>
* The type of the resource to be managed.
*/ */
public abstract class FixedResourcePool <T> { public abstract class FixedResourcePool<T> {
/* /*
* Generic Inner Control Classes * Generic Inner Control Classes ------- ----- ------- ------- * Wrapper *
* ------- ----- ------- ------- * RepairThread
* * Wrapper
* * RepairThread
*/ */
/** /**
* Generic Resource Wrapper * Generic Resource Wrapper
*/ */
private static class Wrapper<T>{ private static class Wrapper<T> {
long timestamp; long timestamp;
T wrapped; T wrapped;
public Wrapper(T wrapped){ public Wrapper(T wrapped) {
this.wrapped=wrapped; this.wrapped = wrapped;
mark(); mark();
} }
public void mark(){ public void mark() {
timestamp= System.currentTimeMillis(); timestamp = System.currentTimeMillis();
} }
public long getLastMark(){ public long getLastMark() {
return timestamp; return timestamp;
} }
} }
@@ -51,42 +51,47 @@ public abstract class FixedResourcePool <T> {
/** /**
* Generic Repair Thread * Generic Repair Thread
*/ */
protected class RepairThread extends Thread{ protected class RepairThread extends Thread {
public void run(){ public void run() {
// Contribute to the repairing and validation effort until the pool is destroyed (finishig=true) // Contribute to the repairing and validation effort until the pool
while(!finishing){ // is destroyed (finishig=true)
while (!finishing) {
Wrapper<T> wrapper; Wrapper<T> wrapper;
try { try {
// Remove the oldest element from the repair queue. // Remove the oldest element from the repair queue.
wrapper = repairQueue.poll(timeBetweenValidation, TimeUnit.MILLISECONDS); wrapper = repairQueue.poll(timeBetweenValidation,
if(wrapper==null){ TimeUnit.MILLISECONDS);
// If I've been waiting too much, i'll check the idle pool if connections need if (wrapper == null) {
// If I've been waiting too much, i'll check the idle
// pool if connections need
// validation and move them to the repair queue // validation and move them to the repair queue
checkIdles(); checkIdles();
continue; continue;
} }
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace();
continue; continue;
} }
// Now, I have something to repair! // Now, I have something to repair!
T resource= wrapper.wrapped; T resource = wrapper.wrapped;
boolean valid= false; boolean valid = false;
// Resources are null right after initialization, it means the same as being an invalid resource // Resources are null right after initialization, it means the
if(resource!=null){ // same as being an invalid resource
valid= isResourceValid(resource); // Validate the resource. if (resource != null) {
if(!valid) fails ++; valid = isResourceValid(resource); // Validate the resource.
if (!valid)
fails++;
} }
// If resource is invalid or null, create a new resource and destroy the invalid one. // If resource is invalid or null, create a new resource and
if(!valid){ // destroy the invalid one.
T replace= createResource(); if (!valid) {
T replace = createResource();
resourcesCreated++; resourcesCreated++;
wrapper.wrapped= replace; wrapper.wrapped = replace;
if(resource!=null) if (resource != null)
destroyResource(resource); destroyResource(resource);
} }
@@ -94,12 +99,14 @@ public abstract class FixedResourcePool <T> {
wrapper.mark(); wrapper.mark();
// Offer the resource to the available resources pool. // Offer the resource to the available resources pool.
if(!availableQueue.offer(wrapper)){ if (!availableQueue.offer(wrapper)) {
System.err.println("This shouldn't happen, offering to available was rejected."); System.err
.println("This shouldn't happen, offering to available was rejected.");
} }
} }
System.out.println("Ending thread ["+Thread.currentThread().getName()+"]"); System.out.println("Ending thread ["
+ Thread.currentThread().getName() + "]");
} }
/** /**
@@ -107,39 +114,43 @@ public abstract class FixedResourcePool <T> {
*/ */
private void checkIdles() { private void checkIdles() {
// Get a sample without removing it // Get a sample without removing it
Wrapper<T> wrapper= availableQueue.peek(); Wrapper<T> wrapper = availableQueue.peek();
// If no available items, nothing to repair. // If no available items, nothing to repair.
if(wrapper==null) if (wrapper == null)
return; return;
// Check if the sampled resource needs to be repaired // Check if the sampled resource needs to be repaired
boolean repairNeeded= isValidationNeeded(wrapper); boolean repairNeeded = isValidationNeeded(wrapper);
if(!repairNeeded) if (!repairNeeded)
return; return;
// Move available resources from the available queue to the repair queue until no repair is needed. // Move available resources from the available queue to the repair
while(repairNeeded){ // queue until no repair is needed.
while (repairNeeded) {
// Get the connection from the available queue and check again. // Get the connection from the available queue and check again.
wrapper= availableQueue.poll(); wrapper = availableQueue.poll();
// No resources in the available queue, nothing to do // No resources in the available queue, nothing to do
if(wrapper==null){ if (wrapper == null) {
repairNeeded= false; repairNeeded = false;
return ; return;
} }
// Add the resource to the corresponding queue, depending on weather the resource needs to be repaired or not. // Add the resource to the corresponding queue, depending on
repairNeeded= isValidationNeeded(wrapper); // weather the resource needs to be repaired or not.
repairNeeded = isValidationNeeded(wrapper);
if(repairNeeded) { if (repairNeeded) {
if(!repairQueue.offer(wrapper)){ if (!repairQueue.offer(wrapper)) {
System.err.print("FATAL: This shouldn't happen, offering to repairing was rejected."); System.err
.print("FATAL: This shouldn't happen, offering to repairing was rejected.");
} }
}else{ } else {
if(!availableQueue.offer(wrapper)){ if (!availableQueue.offer(wrapper)) {
System.err.print("FATAL: This shouldn't happen, offering to available was rejected."); System.err
.print("FATAL: This shouldn't happen, offering to available was rejected.");
} }
} }
} }
@@ -152,9 +163,8 @@ public abstract class FixedResourcePool <T> {
private volatile long failsReported = 0; private volatile long failsReported = 0;
private volatile long fails = 0; private volatile long fails = 0;
private volatile long resourcesCreated = 0; private volatile long resourcesCreated = 0;
private volatile long resourcesProvided= 0; private volatile long resourcesProvided = 0;
private volatile long resourcesReturned= 0; private volatile long resourcesReturned = 0;
/* /*
* Pool metrics accessing methods. * Pool metrics accessing methods.
@@ -185,18 +195,17 @@ public abstract class FixedResourcePool <T> {
*/ */
private LinkedBlockingQueue<Wrapper<T>> availableQueue; private LinkedBlockingQueue<Wrapper<T>> availableQueue;
private LinkedBlockingQueue<Wrapper<T>> repairQueue; private LinkedBlockingQueue<Wrapper<T>> repairQueue;
private HashMap<T, Wrapper<T>> inUse= new HashMap<T, Wrapper<T>>(); private HashMap<T, Wrapper<T>> inUse = new HashMap<T, Wrapper<T>>();
private RepairThread[] repairThreads; private RepairThread[] repairThreads;
private Timer t; private Timer t;
private boolean initializated = false; private boolean initializated = false;
private boolean finishing = false; private boolean finishing = false;
/* /*
* Pool configuration parameters * Pool configuration parameters
*/ */
private String name; private String name;
private long defaultPoolWait=50; private long defaultPoolWait = 50;
private int resourcesNumber = 10; private int resourcesNumber = 10;
private int repairThreadsNumber = 3; private int repairThreadsNumber = 3;
private long timeBetweenValidation = 150000; private long timeBetweenValidation = 150000;
@@ -218,7 +227,9 @@ public abstract class FixedResourcePool <T> {
} }
public void setRepairThreadsNumber(int repairThreadsNumber) { public void setRepairThreadsNumber(int repairThreadsNumber) {
if(initializated) throw new IllegalStateException("Repair threads should be setted up before init()"); if (initializated)
throw new IllegalStateException(
"Repair threads should be setted up before init()");
this.repairThreadsNumber = repairThreadsNumber; this.repairThreadsNumber = repairThreadsNumber;
} }
@@ -231,11 +242,16 @@ public abstract class FixedResourcePool <T> {
} }
public void setName(String name) { public void setName(String name) {
if(initializated) throw new IllegalStateException("Name should be setted up before init()"); if (initializated)
throw new IllegalStateException(
"Name should be setted up before init()");
this.name = name; this.name = name;
} }
public String getName() { public String getName() {
if (name == null || name.isEmpty()) {
name = this.getClass().getName();
}
return name; return name;
} }
@@ -247,38 +263,37 @@ public abstract class FixedResourcePool <T> {
return defaultPoolWait; return defaultPoolWait;
} }
/** /**
* Pool initialization & destruction * Pool initialization & destruction
*/ */
public void destroy() { public void destroy() {
checkInit(); checkInit();
System.out.println("Destroying ["+getName()+"]..."); System.out.println("Destroying [" + getName() + "]...");
// Signal al threads to end // Signal al threads to end
finishing=true; finishing = true;
System.out.println("Destroying ["+getName()+"] threads"); System.out.println("Destroying [" + getName() + "] threads");
// Wait for the Repair Threas // Wait for the Repair Threas
for(int i=0; i < repairThreads.length; i++){ for (int i = 0; i < repairThreads.length; i++) {
boolean joined= false; boolean joined = false;
do { do {
try { try {
repairThreads[i].interrupt(); repairThreads[i].interrupt();
repairThreads[i].join(); repairThreads[i].join();
joined= true; joined = true;
} catch (InterruptedException e) { } catch (InterruptedException e) {
e.printStackTrace(); e.printStackTrace();
} }
} while(!joined); } while (!joined);
} }
System.out.println("Waiting for ["+getName()+"] resources to be returned."); System.out.println("Waiting for [" + getName()
+ "] resources to be returned.");
// Wait for all resources to be returned to the pool // Wait for all resources to be returned to the pool
synchronized (this) { synchronized (this) {
while(!inUse.isEmpty()){ while (!inUse.isEmpty()) {
try { try {
this.wait(); this.wait();
} catch (InterruptedException e) { } catch (InterruptedException e) {
@@ -287,220 +302,250 @@ public abstract class FixedResourcePool <T> {
} }
} }
System.out.println("Destroying ["+getName()+"] resources."); System.out.println("Destroying [" + getName() + "] resources.");
// Destroy resources // Destroy resources
for (Wrapper<T> resource : availableQueue) { for (Wrapper<T> resource : availableQueue) {
destroyResource(resource.wrapped); destroyResource(resource.wrapped);
} }
availableQueue.clear(); availableQueue.clear();
availableQueue= null; availableQueue = null;
for (Wrapper<T> resource : repairQueue) { for (Wrapper<T> resource : repairQueue) {
destroyResource(resource.wrapped); destroyResource(resource.wrapped);
} }
repairQueue.clear(); repairQueue.clear();
repairQueue= null; repairQueue = null;
// Destroy metrics timer // Destroy metrics timer
System.out.println("Shuting metrics timer for ["+getName()+"] down."); System.out.println("Shuting metrics timer for [" + getName()
+ "] down.");
t.cancel(); t.cancel();
t=null; t = null;
// Reset metrics // Reset metrics
failsReported= 0; failsReported = 0;
fails= 0; fails = 0;
resourcesCreated= 0; resourcesCreated = 0;
resourcesProvided= 0; resourcesProvided = 0;
resourcesReturned= 0; resourcesReturned = 0;
// Set states to initial values // Set states to initial values
initializated= false; initializated = false;
finishing=false; finishing = false;
System.out.println("Pool ["+getName()+"] successfully destroyed."); System.out.println("Pool [" + getName() + "] successfully destroyed.");
} }
/** /**
* Initialize the pool * Initialize the pool
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public void init(){ public void init() {
if(initializated==true){ if (initializated == true) {
System.err.println("Warning, double initialization of ["+this+"]"); System.err.println("Warning, double initialization of [" + this
+ "]");
return; return;
} }
initializated=true; initializated = true;
// Create queues with maximum possible capacity // Create queues with maximum possible capacity
availableQueue= new LinkedBlockingQueue<Wrapper<T>>(resourcesNumber); availableQueue = new LinkedBlockingQueue<Wrapper<T>>(resourcesNumber);
repairQueue= new LinkedBlockingQueue<Wrapper<T>>(resourcesNumber); repairQueue = new LinkedBlockingQueue<Wrapper<T>>(resourcesNumber);
// Create and start the repair threads. // Create and start the repair threads.
repairThreads= new FixedResourcePool.RepairThread[repairThreadsNumber]; repairThreads = new FixedResourcePool.RepairThread[repairThreadsNumber];
for(int i=0; i < repairThreads.length; i++){ for (int i = 0; i < repairThreads.length; i++) {
repairThreads[i]= new RepairThread(); repairThreads[i] = new RepairThread();
repairThreads[i].setName("REPAIR["+i+"]:"+name); repairThreads[i].setName("REPAIR[" + i + "]:" + getName());
repairThreads[i].start(); repairThreads[i].start();
} }
// Create resource wrappers with null content. // Create resource wrappers with null content.
for(int i=0; i < resourcesNumber; i++){ for (int i = 0; i < resourcesNumber; i++) {
if(!repairQueue.offer(new Wrapper<T>(null))) if (!repairQueue.offer(new Wrapper<T>(null)))
throw new IllegalStateException("What!? not enough space in the repairQueue to offer the element. This shouldn't happen!"); throw new IllegalStateException(
"What!? not enough space in the repairQueue to offer the element. This shouldn't happen!");
} }
// Schedule a status report every 10 seconds. // Schedule a status report every 10 seconds.
t= new Timer(); t = new Timer();
t.schedule(new TimerTask() { t.schedule(new TimerTask() {
@Override @Override
public void run() { public void run() {
System.out.println("**********************************"); System.out.println("**********************************");
System.out.println("* Pool name:["+name+"]"); System.out.println("* Pool name:[" + name + "]");
System.out.println("* resourcesCreated....:"+getResourcesCreated()); System.out.println("* resourcesCreated....:"
System.out.println("* failsReported.......:"+getFailsReported()); + getResourcesCreated());
System.out.println("* fails...............:"+getFails()); System.out.println("* failsReported.......:"
System.out.println("* resourcesCreated....:"+getResourcesCreated()); + getFailsReported());
System.out.println("* resourcesProvided...:"+getResourcesProvided()); System.out.println("* fails...............:" + getFails());
System.out.println("* resourcesReturned...:"+getResourcesReturned()); System.out.println("* resourcesCreated....:"
System.out.println("* available size......:"+availableQueue.size()); + getResourcesCreated());
System.out.println("* repair size.........:"+repairQueue.size()); System.out.println("* resourcesProvided...:"
+ getResourcesProvided());
System.out.println("* resourcesReturned...:"
+ getResourcesReturned());
System.out.println("* available size......:"
+ availableQueue.size());
System.out.println("* repair size.........:"
+ repairQueue.size());
System.out.println("**********************************"); System.out.println("**********************************");
} }
}, 10000, 10000); }, 10000, 10000);
System.out.println("Initialized ["+name+"]"); System.out.println("Initialized [" + name + "]");
} }
protected void checkInit() {
protected void checkInit(){ if (!initializated)
if(!initializated) throw new IllegalStateException("Call the init() method first!"); throw new IllegalStateException("Call the init() method first!");
} }
/** /**
* Returns true if wrapped resource needs validation * Returns true if wrapped resource needs validation
*
* @param wrapper * @param wrapper
* @return * @return
*/ */
private boolean isValidationNeeded(Wrapper<T> wrapper){ private boolean isValidationNeeded(Wrapper<T> wrapper) {
//Add noise to the check times to avoid simultaneous resource checking. // Add noise to the check times to avoid simultaneous resource checking.
long noisyTimeBetweenCheck= (timeBetweenValidation - (long)((Math.random()-0.5)*(timeBetweenValidation/10))); long noisyTimeBetweenCheck = (timeBetweenValidation - (long) ((Math
.random() - 0.5) * (timeBetweenValidation / 10)));
//Check if the resource need to be checked. // Check if the resource need to be checked.
return wrapper.getLastMark()+noisyTimeBetweenCheck < System.currentTimeMillis(); return wrapper.getLastMark() + noisyTimeBetweenCheck < System
.currentTimeMillis();
} }
/** /**
* Return a resource to the pool. When no longer needed. * Return a resource to the pool. When no longer needed.
*
* @param resource * @param resource
*/ */
public void returnResource(T resource){ public void returnResource(T resource) {
checkInit(); checkInit();
Wrapper<T> wrapper; Wrapper<T> wrapper;
if(resource==null) throw new IllegalArgumentException("The resource shouldn't be null."); if (resource == null)
throw new IllegalArgumentException(
"The resource shouldn't be null.");
//Delete the resource from the inUse list. // Delete the resource from the inUse list.
synchronized (inUse) { synchronized (inUse) {
wrapper= inUse.remove(resource); wrapper = inUse.remove(resource);
} }
if(wrapper==null) throw new IllegalArgumentException("The resource ["+resource+"] isn't in the busy resources list."); if (wrapper == null)
throw new IllegalArgumentException("The resource [" + resource
+ "] isn't in the busy resources list.");
if(isValidationNeeded(wrapper)){ if (isValidationNeeded(wrapper)) {
if(!repairQueue.offer(wrapper)) throw new IllegalStateException("This shouldn't happen. Offering to repair queue rejected."); if (!repairQueue.offer(wrapper))
}else{ throw new IllegalStateException(
if(!availableQueue.offer(wrapper)) throw new IllegalStateException("This shouldn't happen. Offering to available queue rejected."); "This shouldn't happen. Offering to repair queue rejected.");
} else {
if (!availableQueue.offer(wrapper))
throw new IllegalStateException(
"This shouldn't happen. Offering to available queue rejected.");
} }
resourcesReturned++; resourcesReturned++;
if(finishing){ if (finishing) {
synchronized (this) { synchronized (this) {
this.notify(); this.notify();
} }
} }
} }
/** /**
* Return a broken resource to the pool. If the application detects a malfunction of the resource. * Return a broken resource to the pool. If the application detects a
* This resources will go directly to the repair queue. * malfunction of the resource. This resources will go directly to the
* repair queue.
*
* @param resource * @param resource
*/ */
public void returnBrokenResource(T resource){ public void returnBrokenResource(T resource) {
checkInit(); checkInit();
Wrapper<T> wrapper; Wrapper<T> wrapper;
//Delete the resource from the inUse list. // Delete the resource from the inUse list.
synchronized (inUse) { synchronized (inUse) {
wrapper= inUse.remove(resource); wrapper = inUse.remove(resource);
} }
if (wrapper == null)
throw new IllegalArgumentException("The resource [" + resource
+ "] isn't in the busy resources list.");
if(wrapper==null) throw new IllegalArgumentException("The resource ["+resource+"] isn't in the busy resources list."); if (!repairQueue.offer(wrapper))
throw new IllegalStateException(
if(!repairQueue.offer(wrapper)) throw new IllegalStateException("This shouldn't happen. Offering to repair queue rejected."); "This shouldn't happen. Offering to repair queue rejected.");
resourcesReturned++; resourcesReturned++;
if(finishing){ if (finishing) {
synchronized (this) { synchronized (this) {
this.notify(); this.notify();
} }
} }
} }
/** /**
* Get a resource from the pool waiting the default time. * Get a resource from the pool waiting the default time.
* {@link #setDefaultPoolWait(long)} * {@link #setDefaultPoolWait(long)}
*
* @return the resource of type T * @return the resource of type T
* @throws TimeoutException * @throws TimeoutException
*/ */
public T getResource() throws TimeoutException{ public T getResource() throws TimeoutException {
return getResource(defaultPoolWait); return getResource(defaultPoolWait);
} }
/** /**
* Get a resource from the pool. * Get a resource from the pool.
* @param maxTime Max time you would like to wait for the resource *
* @param maxTime
* Max time you would like to wait for the resource
* @return * @return
* @throws TimeoutException * @throws TimeoutException
*/ */
public T getResource(long maxTime) throws TimeoutException{ public T getResource(long maxTime) throws TimeoutException {
if(finishing) if (finishing)
throw new IllegalStateException("Pool ["+getName()+"] is currently being destroyed."); throw new IllegalStateException("Pool [" + getName()
+ "] is currently being destroyed.");
checkInit(); checkInit();
final long tInit= System.currentTimeMillis(); final long tInit = System.currentTimeMillis();
do{ do {
try { try {
long timeSpent= System.currentTimeMillis()-tInit; long timeSpent = System.currentTimeMillis() - tInit;
long timeToSleep= maxTime-timeSpent; long timeToSleep = maxTime - timeSpent;
timeToSleep= timeToSleep>0?timeToSleep:0; timeToSleep = timeToSleep > 0 ? timeToSleep : 0;
if(timeToSleep == 0) throw new TimeoutException(""+timeSpent+">"+maxTime); if (timeToSleep == 0)
Wrapper<T> ret= availableQueue.poll(timeToSleep, TimeUnit.MILLISECONDS); throw new TimeoutException("" + timeSpent + ">" + maxTime);
if(ret!=null){ Wrapper<T> ret = availableQueue.poll(timeToSleep,
TimeUnit.MILLISECONDS);
if (ret != null) {
synchronized (inUse) { synchronized (inUse) {
inUse.put(ret.wrapped, ret); inUse.put(ret.wrapped, ret);
} }
resourcesProvided++; resourcesProvided++;
return ret.wrapped; return ret.wrapped;
} }
} catch (InterruptedException e1) { e1.printStackTrace(); } //If the wait gets interrupted, doesn't matter but print it (just in case). } catch (InterruptedException e1) {
} while(true); e1.printStackTrace();
} // If the wait gets interrupted, doesn't matter but print it (just
// in case).
} while (true);
} }
/* /*
* Implementation dependent methods. To be implemented. * Implementation dependent methods. To be implemented.
*/ */
/** /**
* Create a resource for the pool * Create a resource for the pool
*/ */
@@ -508,6 +553,7 @@ public abstract class FixedResourcePool <T> {
/** /**
* Check if the resource is still valid. * Check if the resource is still valid.
*
* @param resource * @param resource
* @return * @return
*/ */
@@ -515,19 +561,19 @@ public abstract class FixedResourcePool <T> {
/** /**
* Destroy a resource. * Destroy a resource.
*
* @param resource * @param resource
*/ */
protected abstract void destroyResource(T resource); protected abstract void destroyResource(T resource);
@Override @Override
public String toString() { public String toString() {
return getName()+"["+super.toString()+"]"; return getName() + "[" + super.toString() + "]";
} }
/** /**
* Coming features: * Coming features: TODO Busy time check. Cron to check when a resource is
* TODO Busy time check. Cron to check when a resource is being taken for a long time. * being taken for a long time.
*/ */
} }

12
src/test/java/redis/clients/jedis/tests/JedisPoolTest.java
View File

@@ -22,6 +22,7 @@ public class JedisPoolTest extends Assert {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy();
} }
@Test @Test
@@ -35,6 +36,7 @@ public class JedisPoolTest extends Assert {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
pool.returnResource(jedis); pool.returnResource(jedis);
pool.destroy();
} }
@Test @Test
@@ -51,6 +53,8 @@ public class JedisPoolTest extends Assert {
jedis = pool.getResource(200); jedis = pool.getResource(200);
jedis.auth("foobared"); jedis.auth("foobared");
jedis.incr("foo"); jedis.incr("foo");
pool.returnResource(jedis);
pool.destroy();
} }
@Test @Test
@@ -68,6 +72,8 @@ public class JedisPoolTest extends Assert {
jedis = pool.getResource(200); jedis = pool.getResource(200);
jedis.auth("foobared"); jedis.auth("foobared");
jedis.incr("foo"); jedis.incr("foo");
pool.returnResource(jedis);
pool.destroy();
} }
@Test(expected = TimeoutException.class) @Test(expected = TimeoutException.class)
@@ -80,8 +86,8 @@ public class JedisPoolTest extends Assert {
jedis.auth("foobared"); jedis.auth("foobared");
jedis.set("foo", "0"); jedis.set("foo", "0");
jedis = pool.getResource(200); Jedis newJedis = pool.getResource(200);
jedis.auth("foobared"); newJedis.auth("foobared");
jedis.incr("foo"); newJedis.incr("foo");
} }
} }