<p>I fill a collection one single time when my J2EE webapp starts.
Then, several thread may access it at same time but only to read it.</p>

<p>I know using a synchronized collection is mandatory for parallels write but do I still need it for parallels read ?</p>

Normally no because you are not changing the internal state of the collection in this case. When you iterate over the collection a new instance of the iterator is created and the state of the iteration is per iterator instance.
Aside note:
Remember that by keeping a read-only collection you are only preventing modifications to the collection itself. Each collection element is still changeable.
```
```
class Test {
    public Test(final int a, final int b) {
        this.a = a;
        this.b = b;
    }

    public int a;
    public int b;
}

public class Main {

    public static void main(String[] args) throws Exception {
        List<Test> values = new ArrayList<Test>(2);
        values.add(new Test(1, 2));
        values.add(new Test(3, 4));

        List<Test> readOnly = Collections.unmodifiableList(values);
        for (Test t : readOnly) {
            t.a = 5;
        }

        for (Test t : values) {
            System.out.println(t.a);
        }
    }

}
```
```
This outputs:
```
```
5
5
```
```
Important considerations from @WMR answser.
It depends on if the threads that are
  reading your collection are started
  before or after you're filling it. If
  they're started before you fill it,
  you have no guarantees (without
  synchronizing), that these threads
  will ever see the updated values.
The reason for this is the Java Memory
  Model, if you wanna know more read the
  section "Visibility" at this link:
http://gee.cs.oswego.edu/dl/cpj/jmm.html
And even if the threads are started
  after you fill your collection, you
  might have to synchronize because your
  collection implementation could change
  its internal state even on read
  operations (thanks
Michael
  Bar-Sinai
,
  I didn't know such collections
  existed).
Another very interesting read on the
  topic of concurrency which covers
  topics like publishing of objects,
  visibility, etc. in much more detail
  is Brian Goetz's book
Java
  Concurrency in
  Practice
.