[英]Java - Valid Object Pool with fixed number of Objects to be pooled and use wait-notify
我正在尝试实现具有固定数量的对象以供池使用的对象池,并在池为空时使用wait,并在线程释放对象时通知。
我可以使用以下程序来实现上述所需的功能。
我想知道实施是否正确,或者需要从Interview角度进行任何修改?
import java.util.ArrayList;
import java.util.List;
class ObjectPool
{
static List objects = new ArrayList();
static
{
objects.add("Object One");
objects.add("Object Two");
}
public Object getObject()
{
synchronized(objects)
{
if(objects.isEmpty())
{
System.out.println(Thread.currentThread().getName() + " waiting as Object Pool is empty");
try {
objects.wait();
System.out.println(Thread.currentThread().getName() + " Got Notification");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Object locked = objects.get(objects.size()-1);
objects.remove(locked);
System.out.println(Thread.currentThread().getName() + " got lock of object : "+ locked);
return locked;
}
}
public boolean release(Object released)
{
synchronized(objects)
{
System.out.println(Thread.currentThread().getName() + " releasing Object : "+released);
objects.notify();
return objects.add(released);
}
}
}
public class MainforObjectPool implements Runnable
{
static ObjectPool p = new ObjectPool();
public static void main(String[] args)
{
MainforObjectPool m = new MainforObjectPool();
Thread t1 = new Thread(m,"thread 1");
Thread t2 = new Thread(m,"thread 2");
Thread t3 = new Thread(m,"thread 3");
Thread t4 = new Thread(m,"thread 4");
Thread t5 = new Thread(m,"thread 5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
System.out.println("Main Thread Completed");
}
public void run()
{
Object locked = p.getObject();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
p.release(locked);
}
}
很久以前,我使用与您相似的抽象解决了类似的问题。 幸运的是,我将其保存并放在这里 。 为了使这个答案简短,希望能用我的话说清楚,我不会在此处发布整个代码。
您可以拥有一个具有泛型的抽象类,该类可以使您创建自己喜欢的对象的池。 是的,我会像这样使用我的最爱并摆脱它
这个抽象类允许其实现者处理创建/过期对象的逻辑。
此类具有锁定和未 锁定对象的队列。
当您checkIn
入池中的对象时,该对象将进入解锁队列中。
当你checkOut
从池中的对象时,它会检查对象是否应通过调用一个抽象方法过期与否validate()
如果此函数返回true
,则将对象移至锁定队列。 如果此函数返回false
,则将该对象从池中移除,并通过调用抽象函数expire()
使其expire()
(您可以在此使用notify
)。 如果没有将要检出的对象合并,则将其创建并放入锁定队列中。
public abstract class ObjectPool<T> {
private long expirationTime;
private Hashtable<T, Long> locked, unlocked;
public ObjectPool() {
expirationTime = 30000; // 30 seconds
locked = new Hashtable<T, Long>();
unlocked = new Hashtable<T, Long>();
}
/**
* Implemented in concrete class. Create an object to be pooled.
*/
protected abstract T create();
/**
* Used to check whether the object should be kept in the lock, or released.
*/
public abstract boolean validate(T o);
/**
* Object expired. (Use notify?)
*/
public abstract void expire(T o);
public synchronized T checkOut() {
long now = System.currentTimeMillis();
T t;
if (unlocked.size() > 0) {
Enumeration<T> e = unlocked.keys();
while (e.hasMoreElements()) {
t = e.nextElement();
if ((now - unlocked.get(t)) > expirationTime) {
// object has expired
unlocked.remove(t);
expire(t);
t = null;
} else {
if (validate(t)) {
unlocked.remove(t);
locked.put(t, now);
return (t);
} else {
// object failed validation
unlocked.remove(t);
expire(t);
t = null;
}
}
}
}
// no objects available, create a new one
t = create();
locked.put(t, now);
return (t);
}
public synchronized void checkIn(T t) {
locked.remove(t);
unlocked.put(t, System.currentTimeMillis());
}
public synchronized long getExpirationTime() {
return expirationTime;
}
public synchronized void setExpirationTime(long expirationTime) {
this.expirationTime = expirationTime;
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.