If your thread is writing to your array list and event handler is reading from it, you will have to protect the list. Event handler is called on an event queue thread that is started By
java.
Remember that synchronized list will only synchronize on individual method calls, not across calls. So, if for example, you are iterating over list, you will need to synchronize yourself. Also, remember that the list won't protect the objects inside the list. So, if your background thread gets an object from the list and starts modifying it, the synchronized list won't protect you because the call to the objects will be outside the list's methods. You will have to protect those calls yourself
A little advanced concepts in case you are worried about contention between the 2 threads: depending on how long you lock the list, you might run into problems where the UI freezes while the runnable is executing.
What are you doing in the background thread? If your runnable is very light, like let's say it only adds an element to the list, you might want to take a look at copyonwritearraylist. It makes a copy of the list every time you modify it. It's been a while since I've used it, but I think it will work well if number of changes to the list are much lower than number of times the list is read
OTH, if you build the list completely in your runnable, then consider double buffering. Keep one list for reading; awt event queue will use it. In your runnable create a new list and populate it. After you populate it, simply switch the 2 lists; the list that your runnable created becomes the list that awt event queue will use. This way you will only need to put a lock when you switch the lists, not when you are operating on the list. This reduces the amount of contention to almost nothing.
