What pattern is used in Collections.synchronizedList()

Question

I was reading the implementation of method Collections.synchronizedList() and was confused whether its an example of decorator pattern or a proxy pattern?

Answer 1

It's definitely a decorator. It wraps the provided list with a different implementation of the very same interface whose methods alters the behavior (by synchronizing the access) of the very same underlying collection while delegating the methods straight to the wrapped instance.

If it were a proxy pattern, you would not necessarily need to pass the to-be-wrapped collection during construction and those methods would under the covers not necessarily refer exactly the same collection instance on every call.

See also:

• Examples of GoF Design Patterns in Java's core libraries
• Decorator Pattern for IO

Answer 2

I was reading the implementation of method Collections.synchronizedList() and was confused whether its an example of decorator pattern or a proxy pattern?

I agree with @BalusC that it is certainly a decorator which is modifying the functionality of a wrapped object. But I would argue that it also demonstrates aspects of a proxy pattern -- at least how I use the term.

• The wikipedia page on the Proxy Pattern gives as part of its definition "class functioning as an interface to something else".

• In looking at this definition of the proxy design pattern, the author defines it as "Provide a surrogate or placeholder for another object to control access to it."

I think this is what the Collections.synchronizedList() wrapper code is doing by calling through to the delegate:

public E get(int index) {
    return list.get(index);}
public E set(int index, E element) {
    throw new UnsupportedOperationException();
}
public void add(int index, E element) {
    throw new UnsupportedOperationException();
}
public int indexOf(Object o) {
    return list.indexOf(o);
}

In this answer, How do the Proxy, Decorator, Adapter, and Bridge Patterns differ?, the author defines decorators as "Smart Proxy" patterns which I think sounds right. Then there are Aspect Oriented Programming and other similar patterns use both "proxy" and "decoration" in explaining how they work.

Certainly there are proxy patterns which are lazy loaded or sparse in their support for the underlying object's methods and functionality. There are proxy patterns which remote certain portions of an object to a RPC handler which I would argue is a form of decoration.

Answer 3

As per URL https://docs.oracle.com/javase/tutorial/collections/implementations/wrapper.html, Collections.synchronizedList() is example of decorator pattern.