I have a class member that is frequently read from one thread but rarely updated from another thread. How do I efficiently synchronize access to it? I imagine that if I just synchronize every read and write most read synchronizations will be wasted since the object doesn't change between them.

Including code example although it's pretty simple:

```
public class A {

    public static class B {
    }

    private List<B> bs =
        new ArrayList<>();

    public void addB(B b) {
        synchronized (this) {
            bs.add(b);
        }
    }

    public void run() {
        while (true) {
            List<B> bs;
            synchronized (this) {
                bs = new ArrayList<>(this.bs);
            }
            bs.forEach(b -> { /* do something */ });
        }
    }
}

```

assuming `addB` and `run` run from different threads.