org.eclipse.swt.SWTException: Invalid thread access

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

// more code

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

    // If you want to update the UI
    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, runnable);

final List<Task> tasks = taskService.getTasks();
Job job = new Job("My Job") {
    @Override
    protected IStatus run(IProgressMonitor monitor) {
        // convert to SubMonitor and set total number of work units
        SubMonitor subMonitor = SubMonitor.convert(monitor, tasks.size());
        for (Task task : tasks) {
            try {
                // sleep a second
                TimeUnit.SECONDS.sleep(1);

                // set the name of the current work
                subMonitor.setTaskName("I'm working on Task " + task.getSummary());
                
                // workOnTask is a method in this class which does some work
                // pass a new child with the totalWork of 1 to the mehtod
                workOnTask(task, subMonitor.split(1));
                
            } catch (InterruptedException e) {
                return Status.CANCEL_STATUS;
            }
        }
        return Status.OK_STATUS;
    }

};
job.schedule();

protected IStatus run(IProgressMonitor monitor) {
    // convert to SubMonitor and set 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 only 70 % of the work remains
    subMonitor.setWorkRemaining(70);
    
    // do the rest of the work
    workOnTask(task, subMonitor.split(70));
    
    return Status.OK_STATUS;
}

protected IStatus run(IProgressMonitor monitor) {
    // convert to SubMonitor and set 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 only 70 % of the work remains
    subMonitor.setWorkRemaining(70);
    
    // do the rest of the work
    workOnTask(task, subMonitor.split(70));
    
    
    return Status.OK_STATUS;
}

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("Work on Task " + task.getSummary());
    
    SubMonitor loopRelatedTasksMonitor = subMonitor.split(80);
    
    // get related tasks from a service, which should also be preconfigured
    List<Task> relatedTasks = taskService.findRelatedTasks(task);
    
    // setWorkRemaining can also be applied, if the actual work is determined later
    loopRelatedTasksMonitor.setWorkRemaining(relatedTasks.size());
    
    for (Task relatedtask : relatedTasks) {
        preConfigureTask(relatedtask, loopRelatedTasksMonitor.split(1));
    }

    // ... do 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 jakarta.annotation.PostConstruct;
import jakarta.inject.Inject;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
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;

public class ProgressMonitorControl {
  
  private final UISynchronize sync;
  
  private ProgressBar progressBar;
  private GobalProgressMonitor monitor;
  
  @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);
    
    Job.getJobManager().setProgressProvider(new ProgressProvider() {

        @Override
        public IProgressMonitor createMonitor(Job job) {

            StatusUpdateProgressMonitor statusUpdateProgressMonitor = new StatusUpdateProgressMonitor();
            return statusUpdateProgressMonitor.addJob(job);
        }
    });

    private final class StatusUpdateProgressMonitor extends NullProgressMonitor {

    // thread-Safe via thread confinement of the UI-Thread 
    // (means access only via UI-Thread)
    private long runningTasks = 0L;
    
    @Override
    public void beginTask(final String name, final int totalWork) {
      sync.syncExec(new Runnable() {
        
        @Override
        public void run() {
          if( runningTasks <= 0 ) {
            // --- no task is running at the moment ---
            progressBar.setSelection(0);
            progressBar.setMaximum(totalWork);
            
          } else {
            // --- other tasks are running ---
            progressBar.setMaximum(progressBar.getMaximum() + totalWork);
          }
          
          runningTasks++;
          progressBar.setToolTipText("Currently running: " + runningTasks + 
                  "\nLast task: " + name);
        }
      });
    }
  
    @Override
    public void worked(final int work) {
      sync.syncExec(new Runnable() {
  
        @Override
        public void run() {
          progressBar.setSelection(progressBar.getSelection() + work);
        }
      });
    }
    
    public IProgressMonitor addJob(Job job){
      if( job != null ){
        job.addJobChangeListener(new JobChangeAdapter() {
          @Override
          public void done(IJobChangeEvent event) {
            sync.syncExec(new Runnable() {
              
              @Override
              public void run() {
                runningTasks--;
                if (runningTasks > 0 ){
                  // --- some tasks are still running ---
                  progressBar.setToolTipText("Currently running: " + runningTasks);
                  
                } else {
                  // --- all tasks are done (a reset of selection could also be done) ---
                  progressBar.setToolTipText("No background progress running.");
                }
              }
            });
            
            // clean-up
            event.getJob().removeJobChangeListener(this);
          }
        });
      }
      return this;
    }
  }
}

Job job = new Job("My Job") {
    // code as before
};
job.schedule();

Job job = Job.create("CancelAbleJob", monitor -> {
    SubMonitor subMonitor = SubMonitor.convert(monitor, todos.size());
    
    for (Todo todo : todos) {
        if(subMonitor.isCanceled()) {
            return Status.CANCEL_STATUS;
        }
        
        processTodo(subMonitor.newChild(1), todo);
    }
    
    return Status.OK_STATUS;
});
job.schedule();

Job job = Job.create("CancelAbleJob", monitor -> {
    SubMonitor subMonitor = SubMonitor.convert(monitor, todos.size());
    
    for (Todo todo : todos) {
        processTodo(subMonitor.split(1), todo);
    }
    
    // no return value needed when using an ICoreRunnable (since Neon)
});
job.schedule();