那些遇到过的问题

多线程程序在_multiple_ CPU上没有响应,但在单个CPU上很好(更新ListView时)

Meh*_*dad 7 winapi icons multithreading deadlock visual-c++

更新:我转载了这个问题!向下滚动以查看代码.

快速笔记

  • My Core i5 CPU有2个内核,超线程.

  • 如果我打电话SetProcessAffinityMask(GetCurrentProcess(), 1),一切都很好,即使程序仍然是多线程的.

  • 如果我不这样做,并且该程序在Windows XP上运行(在Windows 7 x64上运行正常!),当我滚动列表视图并加载图标时,我的GUI开始锁定几秒钟.

问题

基本上,当我在Windows XP上运行下面发布的程序(我的原始代码的简化版本)时(Windows 7很好),除非我为所有线程强制使用相同的逻辑CPU,程序UI开始滞后半秒或者.

(注意:这里对这篇文章进行了大量编辑,因为我进一步调查了这个问题.)

请注意,线程数相同 - 只有关联掩码不同.

我尝试使用两种不同的消息传递方法:内置GetMessage和我自己的方法BackgroundWorker.

结果？BackgroundWorker 好处从1个逻辑CPU(几乎没有滞后)的亲和力,而GetMessage完全伤害由此,(滞后是现在很多秒长).

我无法弄清楚为什么会发生这种情况 - 多个CPU是否应该比单个CPU 工作得更好？!
当线程数相同时,为什么会出现这样的延迟？

更多统计数据:

GetLogicalProcessorInformation 收益:

0x0: {ProcessorMask=0x0000000000000003 Relationship=RelationProcessorCore ...}
0x1: {ProcessorMask=0x0000000000000003 Relationship=RelationCache ...}
0x2: {ProcessorMask=0x0000000000000003 Relationship=RelationCache ...}
0x3: {ProcessorMask=0x0000000000000003 Relationship=RelationCache ...}
0x4: {ProcessorMask=0x000000000000000f Relationship=RelationProcessorPackage ...}
0x5: {ProcessorMask=0x000000000000000c Relationship=RelationProcessorCore ...}
0x6: {ProcessorMask=0x000000000000000c Relationship=RelationCache ...}
0x7: {ProcessorMask=0x000000000000000c Relationship=RelationCache ...}
0x8: {ProcessorMask=0x000000000000000c Relationship=RelationCache ...}
0x9: {ProcessorMask=0x000000000000000f Relationship=RelationCache ...}
0xa: {ProcessorMask=0x000000000000000f Relationship=RelationNumaNode ...}
Run Code Online (Sandbox Code Playgroud)

代码

下面的代码应该在Windows XP SP3上显示此问题.(至少,它在我的电脑上!)

比较这两个:

  • 正常运行程序,然后滚动.你应该看到滞后.

  • 使用affinity命令行参数运行程序,然后滚动.它应该几乎完全光滑.

为什么会这样？

#define _WIN32_WINNT 0x502

#include <tchar.h>
#include <Windows.h>
#include <CommCtrl.h>

#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "user32.lib")

LONGLONG startTick = 0;

LONGLONG QPC()
{ LARGE_INTEGER v; QueryPerformanceCounter(&v); return v.QuadPart; }

LONGLONG QPF()
{ LARGE_INTEGER v; QueryPerformanceFrequency(&v); return v.QuadPart; }

bool logging = false;
bool const useWindowMessaging = true;   // GetMessage() or BackgroundWorker?
bool const autoScroll = false;   // for testing

class BackgroundWorker
{
    struct Thunk
    {
        virtual void operator()() = 0;
        virtual ~Thunk() { }
    };
    class CSLock
    {
        CRITICAL_SECTION& cs;
    public:
        CSLock(CRITICAL_SECTION& criticalSection)
            : cs(criticalSection)
        { EnterCriticalSection(&this->cs); }
        ~CSLock() { LeaveCriticalSection(&this->cs); }
    };
    template<typename T>
    class ScopedPtr
    {
        T *p;
        ScopedPtr(ScopedPtr const &) { }
        ScopedPtr &operator =(ScopedPtr const &) { }
    public:
        ScopedPtr() : p(NULL) { }
        explicit ScopedPtr(T *p) : p(p) { }
        ~ScopedPtr() { delete p; }
        T *operator ->() { return p; }
        T &operator *() { return *p; }
        ScopedPtr &operator =(T *p)
        {
            if (this->p != NULL) { __debugbreak(); }
            this->p = p;
            return *this;
        }
        operator T *const &() { return this->p; }
    };

    Thunk **const todo;
    size_t nToDo;
    CRITICAL_SECTION criticalSection;
    DWORD tid;
    HANDLE hThread, hSemaphore;
    volatile bool stop;
    static size_t const MAX_TASKS = 1 << 18;  // big enough for testing

    static DWORD CALLBACK entry(void *arg)
    { return ((BackgroundWorker *)arg)->process(); }

public:
    BackgroundWorker()
        : nToDo(0), todo(new Thunk *[MAX_TASKS]), stop(false), tid(0),
        hSemaphore(CreateSemaphore(NULL, 0, 1 << 30, NULL)),
        hThread(CreateThread(NULL, 0, entry, this, CREATE_SUSPENDED, &tid))
    {
        InitializeCriticalSection(&this->criticalSection);
        ResumeThread(this->hThread);
    }

    ~BackgroundWorker()
    {
        // Clear all the tasks
        this->stop = true;
        this->clear();
        LONG prev;
        if (!ReleaseSemaphore(this->hSemaphore, 1, &prev) ||
            WaitForSingleObject(this->hThread, INFINITE) != WAIT_OBJECT_0)
        { __debugbreak(); }
        CloseHandle(this->hSemaphore);
        CloseHandle(this->hThread);
        DeleteCriticalSection(&this->criticalSection);
        delete [] this->todo;
    }

    void clear()
    {
        CSLock lock(this->criticalSection);
        while (this->nToDo > 0)
        {
            delete this->todo[--this->nToDo];
        }
    }

    unsigned int process()
    {
        DWORD result;
        while ((result = WaitForSingleObject(this->hSemaphore, INFINITE))
            == WAIT_OBJECT_0)
        {
            if (this->stop) { result = ERROR_CANCELLED; break; }
            ScopedPtr<Thunk> next;
            {
                CSLock lock(this->criticalSection);
                if (this->nToDo > 0)
                {
                    next = this->todo[--this->nToDo];
                    this->todo[this->nToDo] = NULL;  // for debugging
                }
            }
            if (next) { (*next)(); }
        }
        return result;
    }

    template<typename Func>
    void add(Func const &func)
    {
        CSLock lock(this->criticalSection);
        struct FThunk : public virtual Thunk
        {
            Func func;
            FThunk(Func const &func) : func(func) { }
            void operator()() { this->func(); }
        };
        DWORD exitCode;
        if (GetExitCodeThread(this->hThread, &exitCode) &&
            exitCode == STILL_ACTIVE)
        {
            if (this->nToDo >= MAX_TASKS) { __debugbreak(); /*too many*/ }
            if (this->todo[this->nToDo] != NULL) { __debugbreak(); }
            this->todo[this->nToDo++] = new FThunk(func);
            LONG prev;
            if (!ReleaseSemaphore(this->hSemaphore, 1, &prev))
            { __debugbreak(); }
        }
        else { __debugbreak(); }
    }
};

LRESULT CALLBACK MyWindowProc(
    HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    enum { IDC_LISTVIEW = 101 };
    switch (uMsg)
    {
        case WM_CREATE:
        {
            RECT rc; GetClientRect(hWnd, &rc);

            HWND const hWndListView = CreateWindowEx(
                WS_EX_CLIENTEDGE, WC_LISTVIEW, NULL,
                WS_CHILDWINDOW | WS_VISIBLE | LVS_REPORT |
                LVS_SHOWSELALWAYS | LVS_SINGLESEL | WS_TABSTOP,
                rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
                hWnd, (HMENU)IDC_LISTVIEW, NULL, NULL);

            int const cx = GetSystemMetrics(SM_CXSMICON),
                cy = GetSystemMetrics(SM_CYSMICON);

            HIMAGELIST const hImgList =
                ImageList_Create(
                    GetSystemMetrics(SM_CXSMICON),
                    GetSystemMetrics(SM_CYSMICON),
                    ILC_COLOR32, 1024, 1024);

            ImageList_AddIcon(hImgList, (HICON)LoadImage(
                NULL, IDI_INFORMATION, IMAGE_ICON, cx, cy, LR_SHARED));

            LVCOLUMN col = { LVCF_TEXT | LVCF_WIDTH, 0, 500, TEXT("Name") };
            ListView_InsertColumn(hWndListView, 0, &col);
            ListView_SetExtendedListViewStyle(hWndListView,
                LVS_EX_DOUBLEBUFFER | LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
            ListView_SetImageList(hWndListView, hImgList, LVSIL_SMALL);

            for (int i = 0; i < (1 << 11); i++)
            {
                TCHAR text[128]; _stprintf(text, _T("Item %d"), i);
                LVITEM item =
                {
                    LVIF_IMAGE | LVIF_TEXT, i, 0, 0, 0,
                    text, 0, I_IMAGECALLBACK
                };
                ListView_InsertItem(hWndListView, &item);
            }

            if (autoScroll)
            {
                SetTimer(hWnd, 0, 1, NULL);
            }

            break;
        }
        case WM_TIMER:
        {
            HWND const hWndListView = GetDlgItem(hWnd, IDC_LISTVIEW);
            RECT rc; GetClientRect(hWndListView, &rc);
            if (!ListView_Scroll(hWndListView, 0, rc.bottom - rc.top))
            {
                KillTimer(hWnd, 0);
            }
            break;
        }
        case WM_NULL:
        {
            HWND const hWndListView = GetDlgItem(hWnd, IDC_LISTVIEW);
            int const iItem = (int)lParam;
            if (logging)
            {
                _tprintf(_T("@%I64lld ms:")
                    _T(" Received: #%d\n"),
                    (QPC() - startTick) * 1000 / QPF(), iItem);
            }
            int const iImage = 0;
            LVITEM const item = {LVIF_IMAGE, iItem, 0, 0, 0, NULL, 0, iImage};
            ListView_SetItem(hWndListView, &item);
            ListView_Update(hWndListView, iItem);
            break;
        }
        case WM_NOTIFY:
        {
            LPNMHDR const pNMHDR = (LPNMHDR)lParam;
            switch (pNMHDR->code)
            {
            case LVN_GETDISPINFO:
                {
                    NMLVDISPINFO *const pInfo = (NMLVDISPINFO *)lParam;
                    struct Callback
                    {
                        HWND hWnd;
                        int iItem;
                        void operator()()
                        {
                            if (logging)
                            {
                                _tprintf(_T("@%I64lld ms: Sent:     #%d\n"),
                                    (QPC() - startTick) * 1000 / QPF(),
                                    iItem);
                            }
                            PostMessage(hWnd, WM_NULL, 0, iItem);
                        }
                    };
                    if (pInfo->item.iImage == I_IMAGECALLBACK)
                    {
                        if (useWindowMessaging)
                        {
                            DWORD const tid =
                                (DWORD)GetWindowLongPtr(hWnd, GWLP_USERDATA);
                            PostThreadMessage(
                                tid, WM_NULL, 0, pInfo->item.iItem);
                        }
                        else
                        {
                            Callback callback = { hWnd, pInfo->item.iItem };
                            if (logging)
                            {
                                _tprintf(_T("@%I64lld ms: Queued:   #%d\n"),
                                    (QPC() - startTick) * 1000 / QPF(),
                                    pInfo->item.iItem);
                            }
                            ((BackgroundWorker *)
                             GetWindowLongPtr(hWnd, GWLP_USERDATA))
                                ->add(callback);
                        }
                    }
                    break;
                }
            }
            break;
        }

        case WM_CLOSE:
        {
            PostQuitMessage(0);
            break;
        }
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

DWORD WINAPI BackgroundWorkerThread(LPVOID lpParameter)
{
    HWND const hWnd = (HWND)lpParameter;
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0) > 0 && msg.message != WM_QUIT)
    {
        if (msg.message == WM_NULL)
        {
            PostMessage(hWnd, msg.message, msg.wParam, msg.lParam);
        }
    }
    return 0;
}

int _tmain(int argc, LPTSTR argv[])
{
    startTick = QPC();
    bool const affinity = argc >= 2 && _tcsicmp(argv[1], _T("affinity")) == 0;
    if (affinity)
    { SetProcessAffinityMask(GetCurrentProcess(), 1 << 0); }

    bool const log = logging;  // disable temporarily
    logging = false;

    WNDCLASS wndClass =
    {
        0, &MyWindowProc, 0, 0, NULL, NULL, LoadCursor(NULL, IDC_ARROW),
        GetSysColorBrush(COLOR_3DFACE), NULL, TEXT("MyClass")
    };
    HWND const hWnd = CreateWindow(
        MAKEINTATOM(RegisterClass(&wndClass)),
        affinity ? TEXT("Window (1 CPU)") : TEXT("Window (All CPUs)"),
        WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL);

    BackgroundWorker iconLoader;
    DWORD tid = 0;
    if (useWindowMessaging)
    {
        CreateThread(NULL, 0, &BackgroundWorkerThread, (LPVOID)hWnd, 0, &tid);
        SetWindowLongPtr(hWnd, GWLP_USERDATA, tid);
    }
    else { SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)&iconLoader); }

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        if (!IsDialogMessage(hWnd, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if (msg.message == WM_TIMER ||
            !PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
        { logging = log; }
    }

    PostThreadMessage(tid, WM_QUIT, 0, 0);
    return 0;
}
Run Code Online (Sandbox Code Playgroud)

Mon*_*mas 5

根据您在http://ideone.com/fa2fM上发布的线程间时序,看起来这里有一个公平问题.仅基于这一假设,我的理由就是感知滞后的明显原因以及问题的潜在解决方案.

看起来LVN_GETDISPINFO窗口proc在一个线程上生成并处理了大量消息,而后台工作线程能够保持并以相同的速率将消息发送回窗口,它发布的WM_NULL消息到目前为止,它们已经回到队列中,需要时间才能得到处理.

设置处理器关联掩码时,会为系统引入更多公平性,因为同一处理器必须为两个线程提供服务,这将限制LVN_GETDISPINFO相对于非关联性情况生成消息的速率.这意味着当您发布WM_NULL消息时,窗口proc消息队列可能不会那么深,这反过来意味着它们将"更快"地处理.

看来你需要以某种方式绕过排队效果.使用SendMessage,SendMessageCallback或SendNotifyMessage代替PostMessage很多方法可以做到这一点.在这种SendMessage情况下,您的工作线程将阻塞,直到窗口proc线程完成其当前消息并处理发送的WM_NULL消息,但您将能够更均匀地将WM_NULL消息注入消息处理流程.有关排队与非排队邮件处理的说明,请参阅此页面.

如果您选择使用SendMessage,但由于阻止性质,您不希望限制获取图标的速率SendMessage,那么您可以使用第三个线程.您的I/O线程会将消息发布到第三个线程,而第三个线程用于SendMessage将图标更新注入UI线程.通过这种方式,您可以控制满意图标请求的队列,而不是将它们交错到窗口过程消息队列中.

至于Win7和WinXP之间的行为差​​异,可能有很多原因导致你在Win7上看不到这种效果.可能是列表视图公共控件的实现方式不同,并限制了生成LVN_GETDISPINFO消息的速率.或者,Win7中的线程调度机制可能更频繁或更公平地切换线程上下文.

编辑:

根据您的最新更改,请尝试以下操作:

...

                struct Callback 
                { 
                    HWND hWnd; 
                    int iItem; 
                    void operator()() 
                    { 
                        if (logging) 
                        { 
                            _tprintf(_T("@%I64lld ms: Sent:     #%d\n"), 
                                (QPC() - startTick) * 1000 / QPF(), 
                                iItem); 
                        } 
                        SendNotifyMessage(hWnd, WM_NULL, 0, iItem); // <----
                    } 
                }; 


...

DWORD WINAPI BackgroundWorkerThread(LPVOID lpParameter) 
{ 
    HWND const hWnd = (HWND)lpParameter; 
    MSG msg; 
    while (GetMessage(&msg, NULL, 0, 0) > 0 && msg.message != WM_QUIT) 
    { 
        if (msg.message == WM_NULL) 
        { 
            SendNotifyMessage(hWnd, msg.message, msg.wParam, msg.lParam); // <----
        } 
    } 
    return 0; 
}
Run Code Online (Sandbox Code Playgroud)

编辑2:

在确定LVN_GETDISPINFO使用SendMessage而不是使用消息放入队列之后PostMessage,我们不能用SendMessage自己来绕过它们.

仍然假设在从工作线程发回图标结果之前,wndproc正在处理大量消息,我们需要另一种方法来在准备好后立即处理这些更新.

这是个主意:

  1. 工作线程将结果放置在类似队列的同步数据结构中,然后将(使用PostMessage)WM_NULL消息发布到wndproc(以确保将来某个时间执行wndproc).

  2. 在wndproc的顶部(在case语句之前),UI线程检查同步的类似队列的数据结构以查看是否有任何结果,如果是,则从类似队列的数据结构和进程中删除一个或多个结果他们.

Ivo*_*ops 0

这可能是一个超线程错误。要检查这是否是导致它运行错误程序的原因，并关闭超线程（在 BIOS 中，您通常可以将其关闭）。在过去的五年里，我遇到了两个问题，这些问题只有在启用超线程时才会出现。

归档时间：

查看次数：

1248 次

最近记录：

13 年，2 月 前
在线程中调用SHGetFileInfo以避免UI冻结 6
更多相关链接
相关归档
Vim:在Windows下的终端中编码(Unicode) 21
visual studio 2010 express + win sdk =无法打开输入文件'kernel32.lib' 20
在Erlang的抽象机器BEAM中使用了哪些OS线程？ 15
MSVC constexpr函数'xyz'不能导致常量表达式 10
守护程序线程和低优先级线程之间的区别 8
用于多线程Windows服务的线程库 6
支持Android应用程序中的本地化图标 6
如何编写可自行更新的python代码而无需退出应用程序？ 6
动态更改jQuery Mobile列表视图中的图标 5
如何从图标包加载图标 2
难疑归档
显式关键字是什么意思？ 2753
PHP:从数组中删除元素 2362
如何使用JavaScript漂亮地打印JSON？ 2222
如何在Bash中的分隔符上拆分字符串？ 1885
如何仅从SQL Server DateTime数据类型返回日期 1692
如何恢复Git中丢失的存储？ 1617
计算C#中的相对时间 1461
如何删除重复的行？ 1254
如何在正则表达式中使用变量？ 1250
简单的面试问题变得更难:给出数字1..100,找到丢失的数字 1115