如何在没有主线程的情况下使用统一的“ JobSystem”，而不冻结？

Question

I want to use that load some in backgound , But Jobsystem probably use the main thread , So how to do use jobsystem Wituhot Freezes , is it impossible ?? Or I just use C# Thread?? Dont Use JobSystem ??

struct SleepJob : IJobParallelFor
{
    public void Execute(int index)
    {
        Debug.LogFormat("[SleepJob.Execute] Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(1);
    }
}
struct SleepJob2 : IJobParallelFor
{
    public void Execute(int index)
    {
        Debug.LogFormat("[SleepJob2.Execute] Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(1);
    }
}
[ContextMenu("JobSleep")]
public void JobSleep()
{
    Debug.LogFormat("[JobSleep.Execute] Thread Id {0}", Thread.CurrentThread.ManagedThreadId);

    SleepJob job = new SleepJob() { };
    SleepJob2 job2 = new SleepJob2() { };
    JobHandle jh = job.Schedule(100, 64);
    JobHandle jh2 = job2.Schedule(100, 64, jh);
    JobHandle.ScheduleBatchedJobs();
    jh2.Complete(); // freezes

    Debug.LogFormat("[JobSleep.Execute] jh.Complete();");
}

Answer 1

Make JobHandle jh2 global variable. Check JobHandle.isComplete in Update method or in Coroutine

Answer 2

Note that Complete makes your execution freeze because:

The JobSystem automatically prioritizes the job and any of its dependencies to run first in the queue, then attempts to execute the job itself on the thread which calls the Complete function .

I think this is not the method you want to use.

Rather try waiting for the Job to complete in a Coroutine like eg

[ContextMenu("JobSleep")]
public void JobSleep()
{
    Debug.LogFormat("[JobSleep.Execute] Thread Id {0}", Thread.CurrentThread.ManagedThreadId);

    SleepJob job = new SleepJob() { };
    SleepJob2 job2 = new SleepJob2() { };
    JobHandle jh = job.Schedule(100, 64);
    JobHandle jh2 = job2.Schedule(100, 64, jh);
    JobHandle.ScheduleBatchedJobs();

    StartCoroutine(WaitFor(jh2));
}

IEnumerator WaiFor(JobHandle job)
{
    yield return new WaitUntil(() => job.IsComplete);

    Debug.LogFormat("[JobSleep.Execute] job IsComplete");
}

---

Unfortunately you didn't add the code you actually want to be executed in background.

In general maybe simply using a Thread or async might already solve your problem.

eg with a Thread

// for sending back responses to the main thread
private ConcurrentQueue<Action> callbacks = new ConcurrentQueue<Action>;

// work the callbacks in the main thread
private void Update()
{
    while(callbacks.Count > 0)
    {
        Action callback;
        if(callbacks.TryDequeue(out callback)) callback?.Invoke();
    }
}

// optional callback on success
public void StartBackgroundTask(Action onSuccess = null)
{
    var thread = new Thread(new ParameterizedThreadStart(TheTaskThatTakesAWhile);
    // pass in parameters here
    thread.Start(onSuccess);
}

// Will be running in a background thread
private void TheTaskThatTakesAWhile(Action onSuccess)
{
    // hand this back to the main thread
    callbacks.Enqueue(() => Debug.Log("Long task started ..."));

    // TODO whatever takes so long

    // Note btw that sleep is in milliseconds!
    Thread.Sleep(1000);

    hand this back to the mainthread
    callbacks.Enqueue(() => 
    {
        Debug.Log("Long task started ..."));

        onSuccess?.Invoke();
    }
}

eg using async (which internally also runs in a Thread)

private async Task TheTaskThatTakesAWhile()
{
    // do whatever takes long here
}

// usually you should avoid having async void
// but when including an Action as callback this is fine
public async void StartBackgroundTask(Action onSuccess = null)
{
    await TheTaskThatTakesAWhile();

    onSuccess?.Invoke();
}

Both you could call like eg

StartBackgroundTask(() => {
    // what should happen when done?

    Debug.Log("I'm done!");
});