org.eclipse.swt.SWTException: Invalid thread access

// get UISynchronize injected as a field
@Inject
UISynchronize sync;

// more code

Job job = Job.create("Update table", (ICoreRunnable) monitor -> {
    // do the long-running work here
    // ...

    // use UISynchronize to update the user interface
    sync.asyncExec(() -> {
        // do something in the user interface,
        // e.g., set a text field
    });
});

// start the job
job.schedule();

// show a busy indicator while the runnable is executed
BusyIndicator.showWhile(display, () -> {
    // ... perform the work here ...
});

List<Task> tasks = taskService.getTasks();

Job job = Job.create("Process tasks", (ICoreRunnable) monitor -> {
    // convert to SubMonitor and set the total number of work units
    SubMonitor subMonitor = SubMonitor.convert(monitor, tasks.size());

    for (Task task : tasks) {
        // set the name of the current work
        subMonitor.setTaskName("Working on task " + task.getSummary());

        // workOnTask is a method in this class which does the actual work,
        // pass a child monitor with a total work of 1 to it
        workOnTask(task, subMonitor.split(1));
    }
});
job.schedule();

Job job = Job.create("Process task", (ICoreRunnable) monitor -> {
    // convert to SubMonitor and set the total number of work units
    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);

    if (taskNeedsPreconfiguration(task)) {
        // takes 30 % of the work
        preConfigureTask(task, subMonitor.split(30));
    }

    // ensure that only 70 % of the work remains
    subMonitor.setWorkRemaining(70);

    // do the rest of the work
    workOnTask(task, subMonitor.split(70));
});
job.schedule();

private void preConfigureTask(Task task, IProgressMonitor monitor) {
    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
    subMonitor.setTaskName("Preconfiguring task " + task.getSummary());

    // ... do the configuration
}

private void workOnTask(Task task, IProgressMonitor monitor) {
    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
    subMonitor.setTaskName("Working on task " + task.getSummary());

    // the loop over the related tasks is supposed to do 80 % of the work
    SubMonitor loopMonitor = subMonitor.split(80);

    // get the related tasks from a service
    List<Task> relatedTasks = taskService.findRelatedTasks(task);

    // the actual amount of work is only known at this point
    loopMonitor.setWorkRemaining(relatedTasks.size());

    for (Task relatedTask : relatedTasks) {
        preConfigureTask(relatedTask, loopMonitor.split(1));
    }

    // ... do the work on the actual task with the remaining 20 %
    doWorkOnActualTask(task, subMonitor.split(20));
}

package com.vogella.tasks.ui.toolcontrols;

import java.util.Objects;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.ProgressProvider;
import org.eclipse.e4.ui.di.UISynchronize;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.ProgressBar;

import jakarta.annotation.PostConstruct;
import jakarta.inject.Inject;

public class ProgressMonitorControl {

    private final UISynchronize sync;

    private ProgressBar progressBar;

    // accessed only in the UI thread
    private int runningJobs;

    @Inject
    public ProgressMonitorControl(UISynchronize sync) {
        this.sync = Objects.requireNonNull(sync);
    }

    @PostConstruct
    public void createControls(Composite parent) {
        progressBar = new ProgressBar(parent, SWT.SMOOTH);
        progressBar.setBounds(100, 10, 200, 20);

        // every job scheduled afterwards gets its monitor from this provider
        Job.getJobManager().setProgressProvider(new ProgressProvider() {
            @Override
            public IProgressMonitor createMonitor(Job job) {
                return new ProgressBarMonitor();
            }
        });

        // deregister the provider when the widget is disposed
        progressBar.addDisposeListener(e -> Job.getJobManager().setProgressProvider(null));
    }

    // runs the update in the UI thread, unless the widget is already disposed
    private void updateUi(Runnable update) {
        sync.asyncExec(() -> {
            if (!progressBar.isDisposed()) {
                update.run();
            }
        });
    }

    private final class ProgressBarMonitor extends NullProgressMonitor {

        // accessed only in the UI thread
        private int totalWork;
        private int reportedWork;
        private boolean started;
        private boolean finished;

        @Override
        public void beginTask(String name, int total) {
            updateUi(() -> {
                started = true;
                totalWork = total;
                if (runningJobs == 0) {
                    // no other job is running, reset the bar
                    progressBar.setSelection(0);
                    progressBar.setMaximum(total);
                } else {
                    progressBar.setMaximum(progressBar.getMaximum() + total);
                }
                runningJobs++;
                progressBar.setToolTipText("Running jobs: " + runningJobs);
            });
        }

        @Override
        public void worked(int work) {
            updateUi(() -> report(work));
        }

        // called by the Jobs framework after the job has finished
        @Override
        public void done() {
            updateUi(() -> {
                if (!started || finished) {
                    return;
                }
                finished = true;
                // report the work the job did not report itself, e.g.,
                // the work assigned to the last child of a SubMonitor
                report(totalWork - reportedWork);
                runningJobs--;
                progressBar.setToolTipText(
                        runningJobs == 0 ? "No background job running" : "Running jobs: " + runningJobs);
            });
        }

        private void report(int work) {
            if (work > 0) {
                reportedWork += work;
                progressBar.setSelection(progressBar.getSelection() + work);
            }
        }
    }
}

Job job = Job.create("My Job", (ICoreRunnable) monitor -> {
    // job implementation as before
});
job.schedule();