JavaFX TableView Scroll Time With PropertyValueFactory

This post has been overhauled to examine scrolling in a large table rather than loading.  One of the readers (thanks @kleopatra_jx) pointed out that my original post wasn't correct because the different PropertyValueFactory implementations were only called a few times.  In this updated post, I've made sure that the PropertyValueFactory's call method is invoked via a method that will scroll through the whole TableView.


This screenshot shows a JavaFX application consisting of a TableView and 2 Buttons.  The TableView contains two columns: one for a field Id and one for a field Data.  Pressing the Load Button creates 20,000,000 objects and adds them to the TableView.

Loading a Large TableView

PropertyValueFactory objects are used to display the items on the screen.  The factory is invoked when an object scrolls onto the screen.  I used the following method to scroll through the entire result set.  The Thread was needed because a simple loop seemed to consolidate the scroll operations, scrolling to the last issued scrollTo().  I verified that the Thread approach did not consolidate the calls; the PropertyValueFactory was called many more times.

private void scrollEntireTable() {
 new Thread() {
  @Override
  public void run() {    
   for( int i=50; i<NUM_RECORDS; i=i+50 ) {
    final int pos = i;
    Platform.runLater(() -> tblObjects.scrollTo( pos ));     
   }
  }
 }.start();
}

The first approach I timed used Java Reflection to take a passed-in string (ex, "id" and "data") and return a newly-created ObservableValue.

tcId.setCellValueFactory(new PropertyValueFactory<MyObject,Number>("id"));  
  
tcData.setCellValueFactory(new PropertyValueFactory<MyObject,String>("data"));  

These results are reported in the trials under "Using Default PropertyValueFactoryImplementation".

The second approach I timed did not use Java Reflection.  It accessed the specific value using a direct method call.

tcId.setCellValueFactory(new PropertyValueFactory("id") {
 @Override
 public ObservableValue call(CellDataFeatures param) {
  return new ReadOnlyObjectWrapper(param.getValue().getId());
 }
   
});  
  
tcData.setCellValueFactory(new PropertyValueFactory("data"){   
 @Override
 public ObservableValue call(CellDataFeatures param) {
  return new ReadOnlyObjectWrapper(param.getValue().getData());
 }
});

The non-Reflection version is listed in the Non-Reflection PropertyValueFactory section.

The results were a little surprising.  It turns out the the default implementation performed  better (saving 30 seconds on all the scrolling).  I looked at the code and don't think that Reflection is an issue at all.  The current implementation in the JRE caches the class info so it's a one-time performance hit.  Recall that this is a 20 million record set being scrolled through sequentially so the gap closes with less scrolling.

CPU Results

I used Java VirtualVM to capture the amount of time spent scrolling.  See the following screenshot.

Java VisualVM Measuring Time Spent Scrolling

Initially, I though that Java Reflection might cause a lag with scrolling a large result set.  This turned out not to be the case as the current implementation of PropertyValueFactory caches the Reflection information.