Memory leak in implementing ListModel by myself

Question

Hello,
I have created a class which implements ListModel.
In this class I overwrite "Object getElementAt(int aIndex)" function
of ListModel. What I do inside this function is I read from a
file some bytes and with that byte I create Object and return it.
I think the problem is Garbage Collector cannot remove these returned
Objects after they are shown in the JList component and when not needed
anymore.
Any help would be appriciated,
Thank you very much.
Tamer

Answer 1

import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
import java.io.*;
import java.awt.event.*;
* This class is an implementation of the ListModel Interface (Model for JList),
* that operates on the binary trace file and has additional capabilities for
* handling markers.
public class TraceFileListModel implements ListModel, ActionListener
private Messageinfo mInfo;
private RuntimeInfo rtInfo;
// number of messages incl. markers
private int currentNoOfMessages;
private ListDataListener ldl;
// this timer checks for changes in the trace file size/number of messages
private javax.swing.Timer timer = new javax.swing.Timer(400, this);
// the list model to handle the markers
private DefaultListModel markerModel;
private int messageLocation = 0;
// index file
private RandomAccessFile indexFile;
// trace tool filtering index file
private RandomAccessFile indexFileTTFilterMode;
// binary trace file
private RandomAccessFile traceFile;
private String markerFilePath;
private String protocol;
private byte content[];
private Message m = new AsciiMessage();
private int messageType;
private int messageLength;
private String messageName;
// the state ID
private int processStatus;
// the state ID (redundant)
// addapted interface MS-TTMA
private int processStatusR;
// the self ID (process ID)
private int selfID;
// the process ID
private int processNumber;
// the signal/message ID
private int signalCode;
// the signal/message ID (redundant)
private int signalCodeR;
// the frame number of the signal
private int frameNumber;
// the length (in bytes) of the parameter part of the message as coded
// if the message header
private int messParaLengthCoded;
// the length (bytes) of the parameter part of the message which has
// been actually received (= the length of the message - the header )
private int messParaLengthReceived;
private int size;
private int markerCounter;
private MarkerMessage tmpMarker;
private DataInputStream das;
private Class messageClass;
private IpcMessage ipcmessage;
private byte nc[];
private StringBuffer stateName;
private AsciiMessage asciimessage;
private static final String DEFAULT_MESSAGE_REP = "not defined";
private static final String PROTOCOL_UMTS_GSM = "UMTS/GSM";
private static final String PROTOCOL_GPRS = "GPRS";
private static final String GEN_PREFIX = "Gen_";
private static final String OPEN_BRACKET = "(";
private static final String CLOSE_BRACKET = ")";
private static final String MAC_SUFFIX = "MAC FN: ";
* Creates the object.
public TraceFileListModel(String aTraceFilePath,
String aIndexFilePath,
String aMarkerFilePath,
Messageinfo aMInfo,
RuntimeInfo aRtInfo,
DefaultListModel aMarkerModel,
boolean aHasDynamicData,
String aProtocol) throws IOException
markerModel = aMarkerModel;
mInfo = aMInfo;
rtInfo = aRtInfo;
markerFilePath = aMarkerFilePath;
protocol = aProtocol;
indexFile = new RandomAccessFile(aIndexFilePath,"r");
traceFile = new RandomAccessFile(aTraceFilePath,"r");
// aHasDynamicData: tracing online that means the size of the binary trace
// file will change. Therefore the trace file size has to be taken from the
// RuntimeInfo object and is checked periodically.
if (aHasDynamicData == true) // online
if(rtInfo.getTraceToolFiltering())
indexFileTTFilterMode = new RandomAccessFile(
rtInfo.getTTFilteredModeIndexFilePath(),
"r");
rtInfo.setTopicTraceFileSize(0);
currentNoOfMessages = rtInfo.getTopicTraceFileSize();
markerModel.clear();
timer.setCoalesce(true);
timer.setRepeats(true);
timer.start();
else
if(rtInfo.getTraceToolFiltering())
indexFileTTFilterMode = new RandomAccessFile(
rtInfo.getTTFilteredModeIndexFilePath(),
"rw");
createTTFilterModeIndexFileAndLoadMarkerFile();
indexFileTTFilterMode.seek(0);
currentNoOfMessages = indexFileTTFilterMode.readInt() +
markerModel.getSize();
else
loadMarkerFile();
currentNoOfMessages = indexFile.readInt() + markerModel.getSize();
} // end of Constructor
* (Implements the ListModel.)
public int getSize()
return currentNoOfMessages;
* (Implements the ListModel.)
public Object getElementAt(int aIndex)
messageName = this.DEFAULT_MESSAGE_REP;
// the state ID
processStatus = -1;
// the state ID (redundant)
// addapted interface MS-TTMA
processStatusR = -1;
// the self ID (process ID)
selfID = -1;
// the process ID
processNumber = -1;
// the signal/message ID
signalCode = -1;
// the signal/message ID (redundant)
signalCodeR = -1;
// the frame number of the signal
frameNumber = -1;
// the length (in bytes) of the parameter part of the message as coded
// if the message header
messParaLengthCoded = -1;
// the length (bytes) of the parameter part of the message which has
// been actually received (= the length of the message - the header )
messParaLengthReceived = -1;
try
// here the number of markers before line number "aIndex" are calculated.
size = markerModel.getSize();
markerCounter = 0;
if(rtInfo.getTraceToolFiltering())
for (int i = 0; i < size; i++)
tmpMarker = (MarkerMessage) markerModel.getElementAt(i);
if (tmpMarker.lineNumberFilterMode == aIndex) return tmpMarker;
if (tmpMarker.lineNumberFilterMode > aIndex) break;
markerCounter++;
} // for loop
// the number of markers before line number "aIndex" = markerCounter
// find the read position in the binary trace file
indexFileTTFilterMode.seek((aIndex-markerCounter)*4+4);
traceFile.seek(indexFileTTFilterMode.readInt());
else
for (int i = 0; i < size; i++)
tmpMarker = (MarkerMessage) markerModel.getElementAt(i);
if (tmpMarker.lineNumber == aIndex) return tmpMarker;
if (tmpMarker.lineNumber > aIndex) break;
markerCounter++;
} // for loop
// the number of markers before line number "aIndex" = markerCounter
// find the read position in the binary trace file
indexFile.seek((aIndex-markerCounter)*12+4);
traceFile.seek(indexFile.readInt());
messageType = traceFile.readByte();
messageLength = traceFile.readShort();
if (messageLength > 0)
content = new byte[messageLength];
traceFile.read(content);
else
content = new byte[0];
if (messageType == DataStorer.IPC_ID)
das = new DataInputStream(new ByteArrayInputStream(content));
messParaLengthReceived = das.available()-
SharedConstants.IPC_MESSAGE_TRACE_HEADER_LENGTH;
if(protocol.equalsIgnoreCase(this.PROTOCOL_UMTS_GSM))
processStatus=das.readUnsignedByte();
processStatusR=das.readUnsignedByte();
else if(protocol.equalsIgnoreCase(this.PROTOCOL_GPRS))
processStatus=das.readUnsignedShort();
selfID=das.readUnsignedByte();
processNumber=das.readUnsignedByte();
signalCode=das.readUnsignedByte();
signalCodeR=das.readUnsignedByte();
frameNumber=das.readInt();
messParaLengthCoded=das.readShort();
// get the message name from the self ID/process ID
messageName=mInfo.getSignalName(processNumber,signalCode);
// Construct the Class object representing the message (by name)
messageClass=Class.forName(this.GEN_PREFIX+messageName);
// Construct the object representing the received message
ipcmessage=(IpcMessage) messageClass.newInstance();
// hand over the parameters content, frame number, state name
byte nc[] = new byte[content.length -
                             SharedConstants.IPC_MESSAGE_TRACE_HEADER_LENGTH];
System.arraycopy(content,
SharedConstants.IPC_MESSAGE_TRACE_HEADER_LENGTH,
nc,
0,
nc.length);
ipcmessage.setContent(nc);
ipcmessage.setFrameNumber(frameNumber);
// addapted interface MS-TTMA
if (processStatus < 256)
stateName =
new StringBuffer(mInfo.getStateName(selfID, processStatus));
if (selfID != processNumber)
stateName = stateName.append(this.OPEN_BRACKET);
stateName = stateName.append(mInfo.getProcessName(selfID));
stateName = stateName.append(this.CLOSE_BRACKET);
ipcmessage.setStateName(stateName.toString());
else ipcmessage.setStateName(this.MAC_SUFFIX + processStatus);
ipcmessage.setParameterLength(messParaLengthCoded);
// if the length of the parameter part coded in the trace header
// differs from the length calculated from the length of the
// received data the message is branded as defective by throwing
// an IOException
if (messParaLengthReceived != messParaLengthCoded)
throw new IOException();
// return the message object
return (Message) ipcmessage;
} // if "Ipc Message"
if (messageType == DataStorer.ASCII_ID)
// construct an Ascii Message object
asciimessage=new AsciiMessage();
// hand over the content
asciimessage.setContent(content);
// return the message object
return (Message)asciimessage;
} // if "Ascii Message"
} // try
catch(IOException ioE)
return
provideErrMsg(messageName,processStatus,selfID,processNumber,signalCode);
catch(ClassNotFoundException cnfE)
return
provideErrMsg(messageName,processStatus,selfID,processNumber,signalCode);
catch(IllegalAccessException iaE)
return
provideErrMsg(messageName,processStatus,selfID,processNumber,signalCode);
catch (InstantiationException iE)
return
provideErrMsg(messageName,processStatus,selfID,processNumber,signalCode);
return m;
} // end of method "getElementAt"
* (Implements the ListModel.)
public void addListDataListener(ListDataListener l)
ldl = l;
* (Implements the ListModel.)
public void removeListDataListener(ListDataListener l)
ldl = null;
* Provides an error message object.
public static Message provideErrMsg(String aMessageName,
int aProcessStatus,
int aSelfID,
int aProcessNumber,
int aSignalCode)
StringBuffer text = new StringBuffer("Invalid Message :");
text.append(aMessageName);
text.append(" State: ");
text.append(aProcessStatus);
text.append(" SelfID/ProcessID: ");
text.append(aSelfID);
text.append("/");
text.append(aProcessNumber);
text.append(" SignalID: ");
text.append(aSignalCode);
AsciiMessage message = new AsciiMessage();
message.setContent(text.toString().getBytes());
return message;
} // end of method "provideErrorMessage"
* Stop the timer that supervises the (dynamic) trace file size/number of
* messages. From now on the number of trace messages is fixed.
public void setNoDynamic()
if (timer.isRunning() == true) timer.stop();
int tmpSize = rtInfo.getTopicTraceFileSize();
if (tmpSize > currentNoOfMessages)
ListDataEvent event = new ListDataEvent(this,
ListDataEvent.INTERVAL_ADDED,
currentNoOfMessages, tmpSize-1);
ldl.intervalAdded(event);
currentNoOfMessages = tmpSize;
} // end of method "setDynamicData"
* This method supervises the size of the binary trace file.
public void actionPerformed(ActionEvent e)
size = rtInfo.getTopicTraceFileSize();
if (size > currentNoOfMessages)
ListDataEvent event = new ListDataEvent(this,
ListDataEvent.INTERVAL_ADDED,
currentNoOfMessages, size-1);
ldl.intervalAdded(event);
currentNoOfMessages = size;
} // end of method "actionPerformed"
* Close the used index file and binary trace file explicitly.
private void close() throws IOException
indexFile.close();
traceFile.close();
} // end of method "close"
} // end of TraceFileListModel
Most important part is:
messageClass=Class.forName(this.GEN_PREFIX+messageName);
// Construct the object representing the received message
ipcmessage=(IpcMessage) messageClass.newInstance();
// hand over the parameters content, frame number, state name
byte nc[] = new byte[content.length -SharedConstants.IPC_MESSAGE_TRACE_HEADER_LENGTH];
System.arraycopy(content,
SharedConstants.IPC_MESSAGE_TRACE_HEADER_LENGTH,
nc,
0,
nc.length);
ipcmessage.setContent(nc);
then I return ipcmessage. And I think when I scroll down/up
and when this message is not visiable it should be deleted by Garbage
Collector. Which I think doesnot happen.