这个 "container Design Pattern" 是怎么称呼的?
How is this "container Design Pattern" called?
在创建我的应用程序时。架构 我遇到了对一种结构的需求,这将在下面描述。
我很确定,有一个具有相同功能的众所周知的设计模式,因为我认为我开发它所针对的问题非常普遍。
我自己编写了这个实现,但我总是尝试使用 "build in language" 模式实现,所以 - 请帮我命名这个结构。
这个想法接近于 reader-writer 模式。我们有一个 "container" ,我们可以在其中通过键 () 添加对象。我们也可以通过键获取这些对象,将其从容器中移除。
所以,实现的class应该有两个方法:
void putObject(Key key, Object object);
Object getObject(Key key); // remove <Key,Object> from container.
接下来最有意思了。
这个容器应该在多线程环境下工作如下:
- 如果没有对象关联key,调用get(Key
key) 方法调用者线程应该等待这个对象
容器。
- 当另一个线程调用putObject(Key key, Object object)
方法它应该检查是否有一些线程正在等待
这个对象,如果是 - 然后发出信号并唤醒线程
等待。
我觉得是普通结构,有"official"名字吗?
我的 Java 这个模式的实现:
private static interface BlackBox {
public void addObject(IdObject object);
public IdObject getObject(ObjectId id);
}
private static class BlackBoxImpl implements BlackBox {
private final Lock conditionLock = new ReentrantLock();
private final Map<ObjectId, IdObject> savedObjects;
private final Map<ObjectId, Condition> waitingConditions;
public BlackBoxImpl() {
this.savedObjects = new ConcurrentHashMap<ObjectId, IdObject>(20);
this.waitingConditions = new ConcurrentHashMap<ObjectId, Condition>(20);
}
@Override
public void addObject(IdObject object) {
savedObjects.put(object.getId(), object);
if (waitingConditions.containsKey(object.getId())) {
Condition waitCondition = waitingConditions.get(object.getId());
conditionLock.lock();
waitCondition.signal();
conditionLock.unlock();
}
}
@Override
public IdObject getObject(ObjectId id) {
if (savedObjects.containsKey(id)) {
return savedObjects.get(id);
} else {
conditionLock.lock();
Condition waitCondition = conditionLock.newCondition();
waitingConditions.put(id, waitCondition);
waitCondition.awaitUninterruptibly();
conditionLock.unlock();
return savedObjects.get(id);
}
}
}
private static interface IdObject {
public ObjectId getId();
}
private static class IdObjectImpl implements IdObject {
protected final ObjectId id;
public IdObjectImpl(ObjectId id) {
this.id = id;
}
@Override
public ObjectId getId() {
return id;
}
}
private static interface ObjectId {
}
private static class ObjectIdImpl implements ObjectId {
}
我可能会使用
ConcurrentMap<K,BlockingQue<V>>.
使用Map的并发方法添加对。从您的队列中获取值。使用 ArrayBlockingQue(1).
也许是这样的:
static class MultiQueue<K, V> {
// The base structure.
final ConcurrentMap<K, BlockingQueue<V>> queues = new ConcurrentHashMap<>();
/**
* Put an item in the structure.
*
* The entry in the map will be created if no entry is currently there.
*
* The value will then be posted to the queue.
*/
public void put(K k, V v) throws InterruptedException {
// Make it if not present.
ensurePresence(k).put(v);
}
/**
* Get an item from the structure.
*
* The entry in the map will be created if no entry is currently there.
*
* The value will then be taken from the queue.
*/
public void get(K k) throws InterruptedException {
// Make it if not present - and wait for it.
ensurePresence(k).take();
}
private BlockingQueue<V> ensurePresence(K k) {
// Make it if not present.
return queues.computeIfAbsent(k, v -> new ArrayBlockingQueue(1));
}
}
看看你的设计,对我来说你在描述什么
We have a "container" in which we can add Objects by the key (). And also we can get this objects by keys, removing it from container.
This container should work in multi-threading environment
接近并发Object pool。它使用一组随时可用的初始化对象。池的客户端将从池中请求一个对象并对返回的对象执行操作。
我看到的唯一真正区别是您根据自己的标准获取对象。
在创建我的应用程序时。架构 我遇到了对一种结构的需求,这将在下面描述。
我很确定,有一个具有相同功能的众所周知的设计模式,因为我认为我开发它所针对的问题非常普遍。
我自己编写了这个实现,但我总是尝试使用 "build in language" 模式实现,所以 - 请帮我命名这个结构。
这个想法接近于 reader-writer 模式。我们有一个 "container" ,我们可以在其中通过键 () 添加对象。我们也可以通过键获取这些对象,将其从容器中移除。
所以,实现的class应该有两个方法:
void putObject(Key key, Object object);
Object getObject(Key key); // remove <Key,Object> from container.
接下来最有意思了。 这个容器应该在多线程环境下工作如下:
- 如果没有对象关联key,调用get(Key key) 方法调用者线程应该等待这个对象 容器。
- 当另一个线程调用putObject(Key key, Object object) 方法它应该检查是否有一些线程正在等待 这个对象,如果是 - 然后发出信号并唤醒线程 等待。
我觉得是普通结构,有"official"名字吗?
我的 Java 这个模式的实现:
private static interface BlackBox {
public void addObject(IdObject object);
public IdObject getObject(ObjectId id);
}
private static class BlackBoxImpl implements BlackBox {
private final Lock conditionLock = new ReentrantLock();
private final Map<ObjectId, IdObject> savedObjects;
private final Map<ObjectId, Condition> waitingConditions;
public BlackBoxImpl() {
this.savedObjects = new ConcurrentHashMap<ObjectId, IdObject>(20);
this.waitingConditions = new ConcurrentHashMap<ObjectId, Condition>(20);
}
@Override
public void addObject(IdObject object) {
savedObjects.put(object.getId(), object);
if (waitingConditions.containsKey(object.getId())) {
Condition waitCondition = waitingConditions.get(object.getId());
conditionLock.lock();
waitCondition.signal();
conditionLock.unlock();
}
}
@Override
public IdObject getObject(ObjectId id) {
if (savedObjects.containsKey(id)) {
return savedObjects.get(id);
} else {
conditionLock.lock();
Condition waitCondition = conditionLock.newCondition();
waitingConditions.put(id, waitCondition);
waitCondition.awaitUninterruptibly();
conditionLock.unlock();
return savedObjects.get(id);
}
}
}
private static interface IdObject {
public ObjectId getId();
}
private static class IdObjectImpl implements IdObject {
protected final ObjectId id;
public IdObjectImpl(ObjectId id) {
this.id = id;
}
@Override
public ObjectId getId() {
return id;
}
}
private static interface ObjectId {
}
private static class ObjectIdImpl implements ObjectId {
}
我可能会使用
ConcurrentMap<K,BlockingQue<V>>.
使用Map的并发方法添加对。从您的队列中获取值。使用 ArrayBlockingQue(1).
也许是这样的:
static class MultiQueue<K, V> {
// The base structure.
final ConcurrentMap<K, BlockingQueue<V>> queues = new ConcurrentHashMap<>();
/**
* Put an item in the structure.
*
* The entry in the map will be created if no entry is currently there.
*
* The value will then be posted to the queue.
*/
public void put(K k, V v) throws InterruptedException {
// Make it if not present.
ensurePresence(k).put(v);
}
/**
* Get an item from the structure.
*
* The entry in the map will be created if no entry is currently there.
*
* The value will then be taken from the queue.
*/
public void get(K k) throws InterruptedException {
// Make it if not present - and wait for it.
ensurePresence(k).take();
}
private BlockingQueue<V> ensurePresence(K k) {
// Make it if not present.
return queues.computeIfAbsent(k, v -> new ArrayBlockingQueue(1));
}
}
看看你的设计,对我来说你在描述什么
We have a "container" in which we can add Objects by the key (). And also we can get this objects by keys, removing it from container. This container should work in multi-threading environment
接近并发Object pool。它使用一组随时可用的初始化对象。池的客户端将从池中请求一个对象并对返回的对象执行操作。
我看到的唯一真正区别是您根据自己的标准获取对象。