void clearCache() {
		Map<ROW_OBJECT, Map<Integer, Object>> cachedColumnValues = threadLocalColumnCache.get();
		if (cachedColumnValues != null) {
			cachedColumnValues.clear();
			threadLocalColumnCache.set(null);
		}
	}
This method will retrieve a column value for the given row object.  Further, the retrieved
value will be cached.   This is useful when sorting a table, as the same column value may
be requested multiple times.

<p><u>Performance Notes</u>
<ul>
	<li>This method uses a {@link HashMap} to cache column values for a row object.   Further,
     upon a key collision, the map will perform O(logn) lookups <b>if the key (the row
     object) is {@link Comparable}</b>.   If the key is not comparable, then the collision
     lookups will be linear.    So, make your row objects comparable for maximum speed
     <b>when your table size becomes large</b>  (for small tables there is no observable
     impact).
 <li>Even if your row objects are comparable, relying on this table model to convert your
     row object into column values can be slow <b>for large tables</b>.  This is because the
     default column comparison framework for the tables will call this method multiple
     times, resulting in many more method calls per column value lookup.  For large data,
     the repeated method calls start to become noticeable.  For maximum column sorting
     speed, use a comparator that works not on the column value, but on the row value.  To
     do this, return a comparator from your model's {@link #createSortComparator(int)}
     method, instead of from the column itself or by relying on column item implementing
     {@link Comparable}.  This is possible any time that a row object already has a field
     that is used for a given column.
</ul>

@param rowObject the row object
@param columnIndex the column index for which to get a value
@return the column value
Ghidra/Framework/Docking/src/main/java/docking/widgets/table/threaded/ThreadedTableModel.java