I have a simple class which doesn't require a thread to obtain a lock while reading from my shared object. However if any particular thread tries to modify this shared object, then no thread can read from the object. Bellow is an example of my class.

```
package com.taylor.wall.core.domain;

import java.util.List;

public class Wall {

    // This needs to be synchronized and concurrent
    private List<Post> posts;
    private final Object lock = new Object();

    public void addPost(Post post) {
        synchronized (lock) {
            posts.add(post);
        }
    }

    // Unfortunately this is wasteful, because for threads must now acquire lock before reading
    public List<Post> getPost() {
        synchronized (lock) {
            return posts;
        }
    }
}

```

What would be a better alternative? The wall object is shared amongst many threads. Also declaring my list to be final static is not a good idea because the list is too big to re-create and set.