如何追踪同步错误？

Question

我最近将我的简单图形库设为多线程。现在速度更快了——而且模拟抖动很大，就好像各个地方缓存了旧的位置数据，然后在它“过时”后应用它。

基本上，盒子移动，然后猛拉回来，然后移动，然后猛拉回来......到目前为止还没有发生碰撞，所以不是那样的。

不确定要发布什么代码。

谢谢。

编辑：无论是什么，也会导致滞后峰值。

Edit2：

任务管理器：

public class TaskManager
{
    public delegate void MethodDel(float timestep);
    private Queue<MethodDel> queue;
    private List<TaskHandler> handlers;
    private float value;


    public float Value
    {
        get
        {
            return value;
        }
        set
        {
            this.value = value;
        }
    }


    public TaskManager()
    {
        this.queue = new Queue<MethodDel>();
        this.handlers = new List<TaskHandler>(System.Environment.ProcessorCount);

        for (int t = 0; t < this.handlers.Capacity; ++t)
            this.handlers.Add(new TaskHandler(this));

        foreach (var handler in handlers)
            handler.Start();

        this.value = 0;
    }


    public void Start()
    {
        foreach (var handler in handlers)
            handler.Wake();
    }


    public void Stop()
    {
        lock (queue)
            queue.Clear();

        foreach (var handler in handlers)
            handler.StopWhenDone();
    }


    public void StopWhenDone()
    {
        foreach (var handler in handlers)
            handler.StopWhenDone();
    }


    public void AddToQueue(MethodDel method)
    {
        lock (queue)
            queue.Enqueue(method);
    }


    public bool GetFromQueue(out MethodDel method)
    {
        lock (queue)
        {
            if (queue.Count == 0) { method = null; return false; }

            method = queue.Dequeue();
            return true;
        }
    }


    public int GetQueueCount()
    {
        return queue.Count;
    }

    public void Wait()
    {
        // Have to wait for them one at a time because the main thread is STA.

        WaitHandle[] waitHandles = new WaitHandle[1];
        // for (int t = 0; t < handlers.Count; ++t) waitHandles[t] = handlers[t].WaitHandle;

        // WaitHandle.WaitAll(waitHandles);
        for (int t = 0; t < handlers.Count; ++t) { waitHandles[0] = handlers[t].WaitHandle; WaitHandle.WaitAll(waitHandles); }
    }
}

任务处理程序：

public class TaskHandler
{
    private TaskManager manager;
    private Thread thread;
    private bool stopWhenDone;
    private ManualResetEvent waitHandle;


    public ManualResetEvent WaitHandle
    {
        get
        {
            return waitHandle;
        }
    }


    public TaskHandler(TaskManager manager)
    {
        this.manager = manager;
    }


    public void Start()
    {
        waitHandle = new ManualResetEvent(false);

        stopWhenDone = false;

        thread = new Thread(Run);
        thread.IsBackground = true;
        thread.SetApartmentState(ApartmentState.MTA);
        thread.Start();
    }


    public void StopWhenDone()
    {
        this.stopWhenDone = true;
    }


    private void Run()
    {
        TaskManager.MethodDel curMethod;
        while (true)
        {
            while (!stopWhenDone || manager.GetQueueCount() > 0)
            {
                if (manager.GetFromQueue(out curMethod))
                {
                    curMethod(manager.Value);
                }
            }
            waitHandle.Set();
            waitHandle.WaitOne();
        }
    }


    public void Wake()
    {
        waitHandle.Set();
    }
}

主更新循环：

    public virtual void Update(float timestep)
    {
        taskManager.Value = timestep; taskManager.Start();

        foreach (Camera camera in cameraLookup.Values)
            // camera.Update(timestep);
            taskManager.AddToQueue(camera.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();

        /* foreach (IAffector affector in affectorLookup.Values)
            affector.Update(timestep); */

        foreach (IAffector affector in affectorLookup.Values)
            taskManager.AddToQueue(affector.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();

        // taskManager.StopWhenDone();
        // taskManager.Wait();

        foreach (IConstraint constraint in constraintLookup.Values)
            // constraint.Update(timestep);
            taskManager.AddToQueue(constraint.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();

        foreach (Physic physic in physicLookup.Values)
            // physic.Update(timestep);
            taskManager.AddToQueue(physic.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();

        foreach (Body body in bodyLookup.Values)
            // body.Update(timestep);
            taskManager.AddToQueue(body.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();

        foreach (Model model in modelLookup.Values)
            // model.Update(timestep);
            taskManager.AddToQueue(model.Update);

        taskManager.StopWhenDone();
        taskManager.Wait();
    }

Answer 1

您如何管理数据，您可以在读取数据时进行测试以判断数据是否过时吗？提供有关多线程应用程序的建议非常困难。您可以尝试设置一些跟踪并记录您认为可能存在问题的特定部分。如果您记录了数据更改和读取的时间，您也许能够找出哪里出了问题。

发布一些示例代码，向我们展示如何管理数据，我们可以从那里获取数据。

Answer 2

如果数据变得“过时”，那么您需要修复缓存系统以驱逐/更新旧数据。

线程其实并不难，逻辑很简单。线程的问题是识别共享和未共享的数据，跟踪这些数据，并确保这些数据以正确的顺序更新。其中大部分与程序的结构有关。当您将线程添加到程序中时，结构就变得更加重要。