Right way to fire table changes

Question

suppose i have a class that extends AbstractTableModel and i used a List to store data, like
public class MyTableModel extends AbstractTableModel
List dataList = Collections.synchronizedList(new LinkedList());
public void insertMyData(String data)
synchronized(dataList)
// ... do something
##Line A##
##Line B##
If i want to fire table changes, say like using
this.fireTableDataChanged();
where should i place it?
at ##Line A## or ##Line B## ???
or should I use
SwingUtilities.invokeLater(new Runnable(){public void run(){
  this.fireTableDataChanged();
Moreover, i would like to ask, if I implement my own TableCellRender and overriding the getTableCellRendererComponent method, all the calls like setText, setBackground, setForeground,...
should i use SwingUtilities.invokeLater to do that? or just call it as usual ?
Thanks alot

Answer 1

Since you mention synchronized several times, I assume your model will be accessed from different threads
(although you didn't write this.) Client code will have to be careful: getRowCount may return 10, but by the
time the client gets to row 7 it may no longer exist! What does your model do when getValueAt is based
indices that are out of bounds?
As far as synchronization goes, I think you are going overboard with:
List dataList = Collections.synchronizedList(new LinkedList());...since you are using synchronization blocks elsewhere. In general, I find little use for those synchronizedXXX
factory methods -- usually the class having a collection member provides the thread safety.
As far as the listeners go, model listeners assume their event handlers are executing in the EDT, so
you will have to call the fire*** methods from the EDT. This means you have to use invokeLater or invokeAndWait.
Using invokeAndWait defeats the multithreading you are building, so I think you
should call invokeLater, and since this is an asynchronous-style call it makes no sense doing it
from within a synchronized block. Just be aware that your JTable class may quety the model
out of bounds.
Also, if your model's data is written or changed seldom but read often, I would use the serial immutable
pattern. Have the List reference dataList point to list whose state is immutable. If you want to change
the data, you make a copy, change that and then have dataList refer to the updated copy.