How to progressively synchronize JTable and graph model

Question

I'm trying to find a more or less foolproof way to solve the following problem, and would be grateful if any of you can suggest a better way of doing the following.

My application is handling text that comes from a file and can be of unlimited length (in my current example I have 8,000 words in a text file). For a new project the text (String) is loaded, tokenized (words), the tokens written to a graph model and displayed in a JTable (where they can be tagged). The graph can be saved to XML (and must be, should the project be made loadable).

The table consists of 3 rows (token index, token text, tag).

The problem is, the process of writing each token to the graph model takes a long time (~7 min. for 8,000 wds.). Thus I need to display the JTable before this writing process is completed and make it available for tagging. Not a big problem: Since the actual tokenization (clean & split String) is fast, I can display the table based on the String rather than filling it from the graph model (for tokens and tags).

The problem is rather, that a) the writing-to-graph process must be finished before the model can be saved, and b) that I need to write tags to the model for tokens that might not exist yet (when the user is quicker than the application/the writing process for tokens, e.g. when s/he chooses a tag for the last of a large no. of words while the writing process has only just started). So I want to be able to check the table for newly set tags as soon as possible after the tagging action, check the graph whether the token for the tag exists yet, write the tag if it does, and re-check later if it doesn't.

Here's a prose outline of how I thought it could be done, and I'd be grateful if you had a look at it and let me know whether you see opportunity for optimization and/or bland errors. Would save me a lot of time and re-factoring later.

Thanks a lot!

Preparation

1. Load text from file
2. Clean and split text into tokens
3. Display table based on cleaned and split text
4. Start process of writing tokens to graph (Thread) + update int (e.g., int lastWritten) with index of last token written

Tagging action by user

1. Check if token to be tagged exists in graph (via lastWritten)
   • Yes: Write tag to graph, display tag in table
   • No: Save index of token in a list (e.g., taggedTokenNotWritten), display tag in table
     • Start new Thread that checks whether tokens in taggedTokenNotWritten have been written yet. If so - write tag to token + delete from list; if not - keep in list. Run Thread periodically (e.g., whenever a tag is set*?*).

Save action by user

1. Check whether tokenization process is finished + check whether taggedTokenNotWritten is empty.
   • If yes - save; if no - display message & save only after the above applies.

Answer 1

not answer to your question

everything talking about using Embedded database, there are some issues

1) assumption that File I/O must be redirected to the Background Task

• Runnable#Thread

• SwingWorker

2) you have to implement Paginations

• for SQL engine (better and more confortable)

• for JTable

3) loading data from File I/O could be paused (Thread#sleep(10-25)), to avoids higher CPU performance

4) for that is best of choises DefaultTableModel

5) problem will be if you need to display data from end of File, then you have to iplements two DefaultTableModel and two separate Background Task,

• 1st. only loading required data from end of file and immediatelly to display these data to the JTable,
• 2nd. for load data to the Embedded database

6) that very strange to take the time to load data ~7 min. for 8,000 wds., there are (must be) another problems (not to the discusion my view)

Answer 2

You might be able to leverage this example that uses a SwingWorker to asynchronously process a BlockingQueue of pending entries in its background thread.