Perform initial work in the job

Currently the first thing a reconciler after startup does is to sleep
for a while then call initialProcess then start the processing loop
(that sleeps again...).

This now moves this initial work into the start job so we have a plain
processing loop in the thread to make further improvements easier.

Author: laeubi

bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/reconciler/AbstractReconciler.java

@@ -55,7 +55,7 @@ abstract public class AbstractReconciler implements IReconciler {
 	/**
 	 * Background thread for the reconciling activity.
 	 */
-	class BackgroundThread extends Thread {
+	class BackgroundWorker implements Runnable {
 
 		/** Has the reconciler been canceled. */
 		private boolean fCanceled= false;
@@ -68,16 +68,14 @@ class BackgroundThread extends Thread {
 
 		private boolean fStarted;
 
-		/**
-		 * Creates a new background thread. The thread
-		 * runs with minimal priority.
-		 *
-		 * @param name the thread's name
-		 */
-		public BackgroundThread(String name) {
-			super(name);
-			setPriority(Thread.MIN_PRIORITY);
-			setDaemon(true);
+		private String fName;
+
+		private boolean fIsAlive;
+
+		private volatile Thread fThread;
+
+		public BackgroundWorker(String name) {
+			fName= name;
 		}
 
 		/**
@@ -172,74 +170,79 @@ public void reset() {
 		 */
 		@Override
 		public void run() {
+			try {
+				while (!fCanceled) {
 
-			delay();
-
-			if (fCanceled)
-				return;
-
-			initialProcess();
-
-			while (!fCanceled) {
-
-				delay();
-
-				if (fCanceled)
-					break;
+					delay();
 
-				if (!isDirty()) {
-					waitFinish= false; //signalWaitForFinish() was called but nothing todo
-					continue;
-				}
+					if (fCanceled)
+						break;
 
-				synchronized (this) {
-					if (fReset) {
-						fReset= false;
+					if (!isDirty()) {
+						waitFinish= false; //signalWaitForFinish() was called but nothing todo
 						continue;
 					}
-				}
 
-				DirtyRegion r= null;
-				synchronized (fDirtyRegionQueue) {
-					r= fDirtyRegionQueue.removeNextDirtyRegion();
-				}
+					synchronized (this) {
+						if (fReset) {
+							fReset= false;
+							continue;
+						}
+					}
 
-				fIsActive= true;
+					DirtyRegion r= null;
+					synchronized (fDirtyRegionQueue) {
+						r= fDirtyRegionQueue.removeNextDirtyRegion();
+					}
 
-				fProgressMonitor.setCanceled(false);
+					fIsActive= true;
 
-				process(r);
+					fProgressMonitor.setCanceled(false);
 
-				synchronized (fDirtyRegionQueue) {
-					if (0 == fDirtyRegionQueue.getSize()) {
-						synchronized (this) {
-							fIsDirty= fProgressMonitor.isCanceled();
+					process(r);
+
+					synchronized (fDirtyRegionQueue) {
+						if (0 == fDirtyRegionQueue.getSize()) {
+							synchronized (this) {
+								fIsDirty= fProgressMonitor.isCanceled();
+							}
+							fDirtyRegionQueue.notifyAll();
 						}
-						fDirtyRegionQueue.notifyAll();
 					}
+					fIsActive= false;
 				}
-
-				fIsActive= false;
+			} finally {
+				fIsAlive= false;
 			}
 		}
 
+		boolean isAlive() {
+			return fIsAlive;
+		}
+
 		public void startReconciling() {
-			if (!isAlive()) {
-				if (fStarted) {
-					return;
-				}
+			if (fStarted) {
+				fIsAlive= true;
 				fStarted= true;
 				Job.createSystem("Delayed Reconciler startup", m -> { //$NON-NLS-1$
-					try {
-						start();
-						return Status.OK_STATUS;
-					} catch (IllegalThreadStateException e) {
-						// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=40549
-						// This is the only instance where the thread is started; since
-						// we checked that it is not alive, it must be dead already due
-						// to a run-time exception or error. Exit.
+					//Until we process some code from the job, the reconciler thread is the current thread
+					fThread= Thread.currentThread();
+					delay();
+					if (fCanceled) {
+						return Status.CANCEL_STATUS;
+					}
+					initialProcess();
+					if (fCanceled) {
 						return Status.CANCEL_STATUS;
 					}
+					Thread thread= new Thread(this);
+					thread.setName(fName);
+					thread.setPriority(Thread.MIN_PRIORITY);
+					thread.setDaemon(true);
+					//we will no longer process any code here, so hand over to the worker thread.
+					fThread= thread;
+					thread.start();
+					return Status.OK_STATUS;
 				}).schedule();
 			} else {
 				reset();
@@ -260,8 +263,8 @@ public void documentAboutToBeChanged(DocumentEvent e) {
 		@Override
 		public void documentChanged(DocumentEvent e) {
 
-			if (fThread.isActive() || !fThread.isDirty() && fThread.isAlive()) {
-				if (!fIsAllowedToModifyDocument && Thread.currentThread() == fThread)
+			if (fWorker.isActive() || !fWorker.isDirty() && fWorker.isAlive()) {
+				if (!fIsAllowedToModifyDocument && isRunningInReconcilerThread())
 					throw new UnsupportedOperationException("The reconciler thread is not allowed to modify the document"); //$NON-NLS-1$
 				aboutToBeReconciledInternal();
 			}
@@ -270,13 +273,13 @@ public void documentChanged(DocumentEvent e) {
 			 * The second OR condition handles the case when the document
 			 * gets changed while still inside initialProcess().
 			 */
-			if (fThread.isActive() || fThread.isDirty() && fThread.isAlive())
+			if (fWorker.isActive() || fWorker.isDirty() && fWorker.isAlive())
 				fProgressMonitor.setCanceled(true);
 
 			if (fIsIncrementalReconciler)
 				createDirtyRegion(e);
 
-			fThread.reset();
+			fWorker.reset();
 
 		}
 
@@ -292,11 +295,11 @@ public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput
 					synchronized (fDirtyRegionQueue) {
 						fDirtyRegionQueue.purgeQueue();
 					}
-					if (fDocument != null && fDocument.getLength() > 0 && fThread.isDirty() && fThread.isAlive()) {
+					if (fDocument != null && fDocument.getLength() > 0 && fWorker.isDirty() && fWorker.isAlive()) {
 						DocumentEvent e= new DocumentEvent(fDocument, 0, fDocument.getLength(), ""); //$NON-NLS-1$
 						createDirtyRegion(e);
-						fThread.reset();
-						fThread.suspendCallerWhileDirty();
+						fWorker.reset();
+						fWorker.suspendCallerWhileDirty();
 					}
 				}
 
@@ -316,7 +319,7 @@ public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
 
 			fDocument.addDocumentListener(this);
 
-			if (!fThread.isDirty())
+			if (!fWorker.isDirty())
 				aboutToBeReconciledInternal();
 
 			startReconciling();
@@ -326,7 +329,7 @@ public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
 	/** Queue to manage the changes applied to the text viewer. */
 	private DirtyRegionQueue fDirtyRegionQueue;
 	/** The background thread. */
-	private BackgroundThread fThread;
+	private BackgroundWorker fWorker;
 	/** Internal document and text input listener. */
 	private Listener fListener;
 	/** The background thread delay. */
@@ -475,9 +478,9 @@ public void install(ITextViewer textViewer) {
 		fViewer= textViewer;
 
 		synchronized (this) {
-			if (fThread != null)
+			if (fWorker != null)
 				return;
-			fThread= new BackgroundThread(getClass().getName());
+			fWorker= new BackgroundWorker(getClass().getName());
 		}
 
 		fDirtyRegionQueue= new DirtyRegionQueue();
@@ -511,8 +514,8 @@ public void uninstall() {
 
 			synchronized (this) {
 				// http://dev.eclipse.org/bugs/show_bug.cgi?id=19135
-				BackgroundThread bt= fThread;
-				fThread= null;
+				BackgroundWorker bt= fWorker;
+				fWorker= null;
 				bt.cancel();
 			}
 		}
@@ -618,10 +621,10 @@ protected void forceReconciling() {
 
 		if (fDocument != null) {
 
-			if (!fThread.isDirty()&& fThread.isAlive())
+			if (!fWorker.isDirty()&& fWorker.isAlive())
 				aboutToBeReconciledInternal();
 
-			if (fThread.isActive())
+			if (fWorker.isActive())
 				fProgressMonitor.setCanceled(true);
 
 			if (fIsIncrementalReconciler) {
@@ -638,10 +641,10 @@ protected void forceReconciling() {
 	 * Clients may extend this method.
 	 */
 	protected synchronized void startReconciling() {
-		if (fThread == null)
+		if (fWorker == null)
 			return;
 
-		fThread.startReconciling();
+		fWorker.startReconciling();
 	}
 
 	/**
@@ -657,7 +660,9 @@ protected void reconcilerReset() {
 	 * @return <code>true</code> if running in this reconciler's background thread
 	 * @since 3.4
 	 */
-	protected boolean isRunningInReconcilerThread() {
-		return Thread.currentThread() == fThread;
+	protected synchronized boolean isRunningInReconcilerThread() {
+		if (fWorker == null)
+			return false;
+		return Thread.currentThread() == fWorker.fThread;
 	}
 }