线程池函数1 - 异步调用函数

最新推荐文章于 2022-05-08 13:54:09 发布
最新推荐文章于 2022-05-08 13:54:09 发布
阅读量764 收藏
点赞数
文章标签： thread-poo 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hetoby/article/details/52260256
版权

本次主要针对默认线程池。

//1)使用TrySubmitThreadpoolCallback
//注意每次调用TrySubmitThreadpoolCallback，
//系统都会分配一个工作项work item。
//所以如果打算提交大量的工作项，出于性能和内存的考虑，
//最好使用下面另一组函数。

/*
调用TrySubmitThreadpoolCallback，系统会自动分配work item，该函数通过PostQueuedCompletionStatus将该work item添加到线程池队列中，线程池也由系统创建，并让线程池中的一个线程来调用我们的回调函数，当这个线程处理完一个客户请求之后，它并不会立刻被销毁，而是回到线程池，准备好处理队列中的任何其它的工作项。
*/

//默认线程池，不用考虑后两个参数，定制时才需要
BOOL WINAPI TrySubmitThreadpoolCallback(
  _In_        PTP_SIMPLE_CALLBACK  pfns,
  _Inout_opt_ PVOID                pv,
  _In_opt_    PTP_CALLBACK_ENVIRON pcbe
);
//默认线程池，不用考虑参数，定制时才需要
VOID CALLBACK SimpleCallback(
  _Inout_     PTP_CALLBACK_INSTANCE Instance,
  _Inout_opt_ PVOID                 Context
);
//2）先用CreateThreadpoolWork创建一个工作项，
//然后使用同一个work item来调用SubmitThreadpoolWork提交多个请求
PTP_WORK WINAPI CreateThreadpoolWork(
  _In_        PTP_WORK_CALLBACK    pfnwk,
  _Inout_opt_ PVOID                pv,
  _In_opt_    PTP_CALLBACK_ENVIRON pcbe
);
VOID CALLBACK WorkCallback(
  _Inout_     PTP_CALLBACK_INSTANCE Instance,
  _Inout_opt_ PVOID                 Context,
  _Inout_     PTP_WORK              Work
);
VOID WINAPI SubmitThreadpoolWork(
  _Inout_ PTP_WORK pwk
);
VOID WINAPI WaitForThreadpoolWorkCallbacks(
  _Inout_ PTP_WORK pwk,
  _In_    BOOL     fCancelPendingCallbacks
);
VOID WINAPI CloseThreadpoolWork(
  _Inout_ PTP_WORK pwk
);

1.创建work object, 所有task共用

PTP_WORK WINAPI CreateThreadpoolWork(
    _In_        PTP_WORK_CALLBACK    pfnwk, //回调函数
    _Inout_opt_ PVOID                pv,    //传给回调函数的参数
    _In_opt_    PTP_CALLBACK_ENVIRON pcbe   //回调函数执行环境
);

2.定义异步执行的回调函数

Applications implement this callback if they call the SubmitThreadpoolWork
function to start a worker thread for the work object.

VOID CALLBACK WorkCallback(
    _Inout_     PTP_CALLBACK_INSTANCE Instance,
    _Inout_opt_ PVOID                 Context,
    _Inout_     PTP_WORK              Work
);

3.向线程池提交work请求

系统会自动创建一个默认的线程池，并让线程池中的一个线程来调用我们的回调函数
Posts a work object to the thread pool. A worker thread calls the work object’s callback function.

VOID WINAPI SubmitThreadpoolWork(
    _Inout_ PTP_WORK pwk //created by CreateThreadpoolWork
);

4.等待未完成的callback完成，同时可以取消pending的callback被执行

Waits for outstanding work callbacks to complete and optionally
cancels pending callbacks that have not yet started to execute.

VOID WINAPI WaitForThreadpoolWorkCallbacks(
_Inout_ PTP_WORK pwk,
_In_    BOOL     fCancelPendingCallbacks
);

5.释放work object

Releases the specified work object.
The work object is freed immediately if there are no outstanding callbacks;
otherwise, the work object is freed asynchronously after the outstanding callbacks complete.
If there is a cleanup group associated with the work object, it is not necessary to call this function;
calling the CloseThreadpoolCleanupGroupMembers function releases the work, wait, and timer objects associated with the cleanup group.

VOID WINAPI CloseThreadpoolWork(
    _Inout_ PTP_WORK pwk //created by CreateThreadpoolWork
);

6.实例1

下面的代码是按上面的2）来设计的

BatchDlg.h
class CBatchDlg : public CDialogEx
{
... ...
protected:
    virtual BOOL OnInitDialog();
    afx_msg void OnBnClickedOk();
    afx_msg void OnDestroy();
    afx_msg LRESULT OnCompleted(WPARAM wParam, LPARAM lParam);

private:
    BOOL CreateWorkObject();
    BOOL SubmitWorkToThreadPool();
    void WaitCloseThreadPool();
    static void CALLBACK TaskHandler(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work);

private:
    CListBox m_oLstBox;
    PTP_WORK m_pWorkItem;
};

BatchDlg.cpp
#include <strsafe.h>
#include <Windowsx.h>
#define WM_APP_COMPLETED (WM_APP+123)
HWND g_hDlg = nullptr;
volatile LONG g_nCurrentTask = 0;

void AddMessage(LPCTSTR szMsg) 
{
    HWND hListBox = GetDlgItem(g_hDlg, IDC_LIST1);
    ListBox_SetCurSel(hListBox, ListBox_AddString(hListBox, szMsg));
}
BOOL CBatchDlg::OnInitDialog()
{
    ... ...
    g_hDlg = m_hWnd;
    BOOL bRet = CreateWorkObject();
    ASSERT(bRet);
}
void CBatchDlg::OnBnClickedOk()
{
    BOOL bRet = SubmitWorkToThreadPool();
    ASSERT(bRet);
}
LRESULT CBatchDlg::OnCompleted(WPARAM wParam, LPARAM lParam)
{
    TCHAR szMsg[MAX_PATH + 1];
    StringCchPrintf( szMsg, _countof(szMsg),
        TEXT("____Task #%u was the last task of the batch____"), lParam);
    AddMessage(szMsg);
    ::Button_Enable(::GetDlgItem(m_hWnd, IDOK), TRUE);
    return 0;
}

//-------------------关键代码如下-------------------
//1.创建work object
BOOL CBatchDlg::CreateWorkObject()
{
    ASSERT(nullptr == m_pWorkItem);
    // Create the work item that will be used by all tasks
    m_pWorkItem = CreateThreadpoolWork(TaskHandler, NULL, NULL);
    if (m_pWorkItem == nullptr) {
        ::MessageBox(NULL, TEXT("Impossible to create the work item for tasks."), 
                    TEXT(""), MB_ICONSTOP);
        return FALSE;
    }

    return TRUE;
}
//2.定义异步执行的回调函数
void CALLBACK CBatchDlg::TaskHandler(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work)
{
    LONG currentTask = InterlockedIncrement(&g_nCurrentTask);

    TCHAR szMsg[MAX_PATH];
    StringCchPrintf(szMsg, _countof(szMsg),
        TEXT("[%u] Task #%u is starting."), GetCurrentThreadId(), currentTask);
    AddMessage(szMsg);

    // Simulate a lot of work
    Sleep(currentTask * 1000);

    StringCchPrintf(szMsg, _countof(szMsg),
        TEXT("[%u] Task #%u is done."), GetCurrentThreadId(), currentTask);
    AddMessage(szMsg);

    if (InterlockedDecrement(&g_nCurrentTask) == 0)
    {   // Notify the UI thread for completion.
        ::PostMessage(g_hDlg, WM_APP_COMPLETED, 0, (LPARAM)currentTask);
    }
}
//3.向线程池提交work请求
BOOL CBatchDlg::SubmitWorkToThreadPool()
{
    if (m_pWorkItem == nullptr) {
        ::MessageBox(NULL, TEXT("Impossible to create the work item for tasks."), 
                    TEXT(""), MB_ICONSTOP);
        return FALSE;
    }
    ::Button_Enable(::GetDlgItem(g_hDlg, IDOK), FALSE);
    AddMessage(TEXT("----Start a new batch----"));
    // Submit 4 tasks by using the same work item
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    AddMessage(TEXT("4 tasks are submitted."));

    return TRUE;
}
//4,5.释放work object
void CBatchDlg::WaitCloseThreadPool()
{
    if (m_pWorkItem == nullptr)
        return;

    //WaitForThreadpoolWorkCallbacks(m_pWorkItem, TRUE);
    CloseThreadpoolWork(m_pWorkItem);
}

7.实例2

7.1 MyObj .h/cpp，CMyObj 类，线程池函数要处理的对象

class CMyObj : public CObject
{
public:
    CMyObj(const CString& strName, int nNum, CListBox& lstBox);
    virtual ~CMyObj();

public:
    BOOL DoSth();
    BOOL IsDone()const;

protected:
    void AddMsg(const CString& strMsg);

protected:
    CListBox&           m_lstBox;
    CString             m_strName;
    int                 m_nNum; 
    BOOL                m_bIsDone;
};
// CMyObj
CMyObj::CMyObj(const CString& strName, int nNum, CListBox& lstBox)
    : m_nNum(nNum)
    , m_lstBox(lstBox)
    , m_strName(strName)
    , m_bIsDone(FALSE)
{
}
CMyObj::~CMyObj()
{
    TRACE(_T("[%s] is released\n"), m_strName);
}

// CMyObj member functions
BOOL CMyObj::DoSth()
{
    CString strMsg;
    for (int i = 0; i < m_nNum; ++i)
    {
        strMsg.Format(_T("%s, %04d, %p, threadId=%u"), m_strName, i, this, GetCurrentThreadId());
        AddMsg(strMsg);
        Sleep(500);
    }

    m_bIsDone = TRUE;

    return TRUE;
}

BOOL CMyObj::IsDone()const
{
    return m_bIsDone;
}

void CMyObj::AddMsg(const CString& strMsg)
{
    m_lstBox.AddString(strMsg);
}

7.2 ObjManager.h/cpp, CObjManager管理CMyObj对象

class CMyObj;
class CObjManager
{
public:
    CObjManager();
    ~CObjManager();    
    //clean
    void CleanCompleteObj();
    void ReleaseAll();
    //create object
    void AddObjToBacklogList(const CString& strName, int nNum, CListBox& lstbox);
    void SetCreating(BOOL bCreate);
    BOOL IsCreating()const;
    //handle object
    void SetRunning(BOOL bRun);
    BOOL IsRunning()const;
    BOOL HandleOneObj();
    void AddObjToWorkingList(CObject* obj);

private:
    CObList             m_oBacklogList;
    CCriticalSection    m_csBacklogList;
    BOOL                m_bIsCreating;
    //
    CObList             m_oWorkingList;
    CCriticalSection    m_csWorkingList;
    BOOL                m_bIsRunning;
};
CObjManager::CObjManager()
    : m_bIsRunning(FALSE)
    , m_bIsCreating(FALSE)
{
}
CObjManager::~CObjManager()
{
    ReleaseAll();
}

//控制是否继续往链表里面添加待处理对象
void CObjManager::SetCreating(BOOL bCreate)
{
    m_bIsCreating = bCreate;
}
BOOL CObjManager::IsCreating()const
{
    return m_bIsCreating;
}

//控制是否继续处理链表中的待处理项
void CObjManager::SetRunning(BOOL bRun)
{
    m_bIsRunning = bRun;
}
BOOL CObjManager::IsRunning()const
{
    return m_bIsRunning;
}

//新增加一个待处理对象，放入backlog列表
void CObjManager::AddObjToBacklogList(const CString& strName, int nNum, CListBox& lstbox)
{
    CSingleLock sLock(&m_csBacklogList, TRUE);
    CMyObj* pObj = new CMyObj(strName, nNum, lstbox);
    if (nullptr != pObj)
    {
        POSITION pos = m_oBacklogList.AddTail(pObj);
        ASSERT(pos);
    }
}

//从backlog列表中拿一个对象，放入working列表，并开始处理这个对象
BOOL CObjManager::HandleOneObj()
{
    POSITION pos = nullptr;
    CMyObj* pObj = nullptr;
    {
        CSingleLock sLock(&m_csBacklogList, TRUE);
        pos = m_oBacklogList.GetHeadPosition();
        if (pos == nullptr)
            return FALSE;

        pObj = (CMyObj*)m_oBacklogList.GetAt(pos);
        m_oBacklogList.RemoveAt(pos);
        AddObjToWorkingList(pObj);
    }
    if (nullptr != pObj)
        pObj->DoSth();

    return TRUE;
}

//把对象放入working列表
void CObjManager::AddObjToWorkingList(CObject* obj)
{
    if (nullptr == obj)
        return;

    CSingleLock sLock(&m_csWorkingList, TRUE);
    POSITION pos = m_oWorkingList.AddTail(obj);
    ASSERT(pos);
}

void CObjManager::CleanCompleteObj()
{
    CMyObj* pObj = nullptr;
    POSITION pos = nullptr, posPre = nullptr;
    CSingleLock oLock(&m_csWorkingList, TRUE);
    for (pos = m_oWorkingList.GetHeadPosition();  (posPre = pos) != nullptr;)
    {
        if (!IsRunning())
            break;
        pObj = (CMyObj*)m_oWorkingList.GetNext(pos);
        if (nullptr == pObj)
        {
            m_oWorkingList.RemoveAt(posPre);            
        }   
        else if (pObj->IsDone())
        {
            m_oWorkingList.RemoveAt(posPre);
            delete pObj;
        }
    }
}

void CObjManager::ReleaseAll()
{
    CObject* pObj = nullptr;
    POSITION pos = nullptr;
    {
        CSingleLock sLock(&m_csBacklogList, TRUE);
        for (pos = m_oBacklogList.GetHeadPosition(); pos != nullptr;)
        {
            pObj = m_oBacklogList.GetNext(pos);
            if (nullptr == pObj)
                continue;
            delete pObj;
        }
        m_oBacklogList.RemoveAll();
    }
    //
    {
        CSingleLock oLock(&m_csWorkingList, TRUE);
        for (pos = m_oWorkingList.GetHeadPosition(); pos != nullptr;)
        {
            pObj = m_oWorkingList.GetNext(pos);
            if (nullptr == pObj)
                continue;
            delete pObj;
        }
        m_oWorkingList.RemoveAll();
    }
}

7.3 对话框类

// CBatchDlg dialog
class CBatchDlg : public CDialogEx
{
... ...
protected:
    virtual BOOL OnInitDialog();
    afx_msg void OnDestroy();
    afx_msg void OnBnClickedOk();   
    afx_msg void OnBnClickedBtnHandleObj();
public:
    void CloseCreatObjThread();
    void CloseCleanObjThread();
private:
    BOOL CreateWorkObject();
    void SubmitWorkToThreadPool();
    void WaitCloseThreadPool();
    static void CALLBACK TaskHandler(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work);
    static DWORD WINAPI CreateObjThread(LPVOID lpParam);
    static DWORD WINAPI CleanObjThread(LPVOID lpParam);

public:
    CListBox            m_oLstBox;//输出信息
    static CObjManager  m_objMgr; //管理所有要处理的对象
private:
    PTP_WORK            m_pWorkItem;//线程池对象
    HANDLE              m_hCreatObjThread;//创建要处理对象的线程
    HANDLE              m_hCleanObjThread;//清理完成处理的对象
};

CObjManager CBatchDlg::m_objMgr;

CBatchDlg::CBatchDlg(CWnd* pParent /*=NULL*/)
    : CDialogEx(IDD_BATCH_DIALOG, pParent)
    , m_pWorkItem(nullptr)
    , m_hCreatObjThread(nullptr)
    , m_hCleanObjThread(nullptr)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
BEGIN_MESSAGE_MAP(CBatchDlg, CDialogEx)
    ON_WM_DESTROY()
    ON_BN_CLICKED(IDOK, &CBatchDlg::OnBnClickedOk)
    ON_BN_CLICKED(IDC_BTN_HANDLE_OBJ, &CBatchDlg::OnBnClickedBtnHandleObj)
END_MESSAGE_MAP()

//1.定义线程池的线程函数（异步执行的回调函数）
void CALLBACK CBatchDlg::TaskHandler(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work)
{
    while (m_objMgr.IsRunning())
    {
        if (!m_objMgr.HandleOneObj())
            Sleep(10);
    }
    TRACE(_T("Exit Thread CBatchDlg::TaskHandler: id = %x\n"), GetCurrentThreadId());
}

//2.创建work object
BOOL CBatchDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    SetIcon(m_hIcon, TRUE);
    SetIcon(m_hIcon, FALSE);

    //2.创建work object
    BOOL bRet = CreateWorkObject();
    ASSERT(bRet);

    return TRUE;  // return TRUE  unless you set the focus to a control
}
//2.创建work object
BOOL CBatchDlg::CreateWorkObject()
{
    ASSERT(nullptr == m_pWorkItem);

    // Create the work item that will be used by all tasks
    m_pWorkItem = CreateThreadpoolWork(TaskHandler, NULL, NULL);
    if (m_pWorkItem == nullptr) {
        ::MessageBox(NULL, TEXT("Impossible to create the work item for tasks."), 
                    TEXT(""), MB_ICONSTOP);
        return FALSE;
    }

    return TRUE;
}

//3.创建“生产者”线程，不断的创建待处理对象
void CBatchDlg::OnBnClickedOk()
{
    if (m_hCreatObjThread)
    {
        m_objMgr.SetCreating(FALSE);
        SetDlgItemText(IDOK, _T("Start Create"));
        return;
    }

    m_objMgr.SetCreating(TRUE);
    m_hCreatObjThread = CreateThread(
        NULL,                   // default security attributes
        0,                      // use default stack size  
        CreateObjThread,       // thread function name
        this,                  // argument to thread function 
        0,                      // use default creation flags 
        NULL);                  // returns the thread identifier 
    if (NULL == m_hCreatObjThread)
    {
        m_objMgr.SetCreating(FALSE);
        SetDlgItemText(IDOK, _T("Start Create"));
    }
    else
    {
        SetDlgItemText(IDOK, _T("Stop Create"));
    }
}
DWORD WINAPI CBatchDlg::CreateObjThread(LPVOID lpParam)
{
    CBatchDlg* pThis = (CBatchDlg*)lpParam;
    if (nullptr == pThis)
        return 0;

    static LONG lCount = 0;
    CString strName(_T(""));
    while (m_objMgr.IsCreating())
    {
        ++lCount;
        strName.Format(_T("Obj[%ld]"), lCount);
        m_objMgr.AddObjToBacklogList(strName, 10, pThis->m_oLstBox);
        Sleep(1000);
    }

    pThis->CloseCreatObjThread();
    TRACE(_T("Exit Thread CBatchDlg::CreateObjThread\n"));

    return 0;
}
void CBatchDlg::CloseCreatObjThread()
{
    if (nullptr != m_hCreatObjThread)
    {
        CloseHandle(m_hCreatObjThread);
        m_hCreatObjThread = nullptr;
    }
}

//4.创建清理线程，向线程池提交work请求
void CBatchDlg::OnBnClickedBtnHandleObj()
{
    if (nullptr == m_hCleanObjThread) 
    {
        m_hCleanObjThread = CreateThread(
            NULL,                   // default security attributes
            0,                      // use default stack size  
            CleanObjThread,       // thread function name
            NULL,                  // argument to thread function 
            0,                      // use default creation flags 
            NULL);                  // returns the thread identifier 
    }

    if (m_objMgr.IsRunning())
    {
        m_objMgr.SetRunning(FALSE);
        Sleep(3000);//等待线程池中的线程退出
        SetDlgItemText(IDC_BTN_HANDLE_OBJ, _T("Start Work"));
        return;
    }

    m_objMgr.SetRunning(TRUE);

    SubmitWorkToThreadPool();

    SetDlgItemText(IDC_BTN_HANDLE_OBJ, _T("Stop Work"));
}
void CBatchDlg::SubmitWorkToThreadPool()
{
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
    SubmitThreadpoolWork(m_pWorkItem);
}
DWORD WINAPI CBatchDlg::CleanObjThread(LPVOID lpParam)
{
    while (m_objMgr.IsRunning())
    {
        m_objMgr.CleanCompleteObj();
        Sleep(1000);
    }
    TRACE(_T("Exit Thread CBatchDlg::CleanObjThread\n"));
    return 0;
}
void CBatchDlg::CloseCleanObjThread()
{
    if (nullptr != m_hCleanObjThread)
    {
        CloseHandle(m_hCleanObjThread);
        m_hCleanObjThread = nullptr;
    }
}

//5. 释放“生产者”线程，等待线程池线程结束，释放线程池work object
void CBatchDlg::OnDestroy()
{
    m_objMgr.SetRunning(FALSE);
    m_objMgr.SetCreating(FALSE);
    Sleep(3000);
    CloseCreatObjThread();
    CloseCleanObjThread();
    WaitCloseThreadPool();

    CDialogEx::OnDestroy();
}
//5.释放work object
void CBatchDlg::WaitCloseThreadPool()
{
    if (m_pWorkItem == nullptr)
        return;

    //WaitForThreadpoolWorkCallbacks(m_pWorkItem, FALSE);
    //WaitForThreadpoolWorkCallbacks(m_pWorkItem, TRUE);
    CloseThreadpoolWork(m_pWorkItem);
}

8. 待解决问题 WaitForThreadpoolWorkCallbacks 导致失去响应

据说 devenv.exe /safemode运行就不会出这个现象，但试了不行。

hetoby
关注
异步函数顺序执行的实现
2byte
03-24 2017
这几天在研究实现一个类似Promise思想的库，也不完全一样，主要目标是保证异步事件的执行顺序。 比如有四个异步事件A,B,C,D 需要这样一个执行顺序 A => B => C => D 想了好几种方案。 其中有一种是先建立一个任务链表，执行时修改每个事件的函数内容。假设现在任务链表顺序已经建立， A => B => C => D。taskList[function A,function
线程池的使用与异步调用
u010585277的博客
09-27 413
线程池的使用与异步调用 线程池的使用 禁止使用ExecutorService 在使用线程池时，阿里巴巴开发规范中有强制规定，使用ThreadPoolExecutor来创建线程池，而不是ExecutorService。 原因分析： 假如使用ExecutorService来创建线程池，可以看下构造方法： /** * Creates a thread pool that reuses a fixed number of threads * operating off a shared
线程池之函数的执行
Keequen Liu的随笔
04-14 820
         static void Main(string[] arg)        {            WaitCallback waitCallback;   //回调委托            waitCallback = new WaitCallback(CallBack);            try            {                System.
异步调用函数
mydreamteam的专栏
09-02 509
public delegate int AddDelegate(int a, int b);         public static AddDelegate addMethod;
异步调用
四季帆的博客
05-14 169
在同步调用下，调用方不再继续执行而是暂停等待，被调函数执行完后很自然的就是调用方继续执行，那么异步调用下调用方怎知道被调函数是否执行完成呢？ 这就分为了两种情况： 1.调用方根本就不关心执行结果 2.调用方需要知道执行结果 第一种情况比较简单，可以通过回调来解决，也就是常说的callback，当被调用函数执行完毕后会去执行回调函数。 第二种情况下可以通过通知机制来解决，也就是说当任务执行完成后发送信号来通知调用方任务完成，注意这里的信号有很多实现方式，Linux中的signal，或者使
线程池内核对象触发调用函数
qq_39851127的博客
03-22 221
如果想注册一个工作项，等待一个内核对象被触发的时候去执行，与之前说过的步骤很相似，首先编写如下原型的函数： VOID CALLBACK KernelObjCallback( PTP_CALLBACK_INSTANCE pInstance, PVOID pvContext, PTP_WAIT pWait, TP_WAIT_RESULT WaitResult )； pWait是CreateThreadpoolWait函数返回的对象，WaitResult是DWORD的值，可能的值是WAIT_OBJECT_0，WA
异步线程池
qq_54516125的博客
05-08 3816
异步&线程池 1、初始化线程的4种方式 2，线程池的七大参数 3，Executors中常见四种线程池 4，开发中为什么使用线程池 CompletableFuture异步编排 1创建异步对象 2计算完成时回调方法 3handle方法 4线程串行化方法 5两任务组合-都要完成 6两个任务组合-一个完成 7多任务组合
python如何实现异步调用函数执行
09-19
### Python 实现异步调用函数执行 #### 一、同步与异步概念解析 在深入探讨Python如何实现异步调用之前，我们先来理解同步调用与异步调用的基本概念。 - **同步调用**：在同步调用模式下，程序执行流程是按顺序...
Python3-异步进程回调函数(callback())介绍
09-16
在这个例子中，`download`函数是被异步调用的任务，当它执行完毕后，返回的结果会被传递给`alterUser`回调函数。 ```python p = Pool(3) p.apply_async(func=download, callback=alterUser) ``` 这里的`alterUser`...
易语言IOCP线程池模块源码-易语言
06-13
1. **线程池的创建与管理**：线程池的初始化通常包括创建IOCP、分配工作线程、设置完成端口回调函数等步骤。在易语言中，这些操作需要通过系统API函数实现，如`CreateIoCompletionPort`用于创建I/O完成端口，`...
Java多线程实现异步调用的方法
09-03
本文给大家分享java多线程实现异步调用的方法，感兴趣的朋友跟着脚本之家小编一起学习吧
Windows下一个比较完美的线程池实现和示例
03-03
Windows下一个比较完美的线程池实现和示例 本线程池提供了如下功能： 1.能根据任务个数和当前线程的多少在最小/最大线程个数之间自动调整(Vista后的系统有 SetThreadpoolThreadMaximum 等函数有类似功能)； 2.能方便的对任一任务进行取消操作，无论该任务是等待运行状态还是正在运行状态都支持(相比较而言，WaitForThreadpoolWorkCallbacks 函数只能取消尚未运行的任务)； 3.能对整个线程池进行安全的暂停、继续、停止处理 4.支持回调方式的反馈通知 5.使用模版方式实现，能方便的进行参数传递 6.在加入任务时可以设置优先级(目前尚不支持动态调整) 7.使用的是微软的基本API，能支持WinXP、Vista、Win7等各种操作系统(CreateThreadpoolWork 等只能在Vista后才能使用) 详细说明参见本人博客
异步调用及回调函数
weixin_42971706的博客
10-31 408
主要知识点 同步调用：会等进程执行完才会执行下一个进程（串行） 异步调用：简单理解就是并行 回调函数：pool.submit().add_done_callback(funcname) ,参数为要执行的函数名，在并行的情况解决了函数需要传递函数的问题，接受参数的函数内部，需要使用 res.result() 来取值，不然是一个对象。 from concurrent.futures import ...
ThreadPool的worker函数
litianze99的专栏
10-27 1117
threadpool的worker函数，worker函数是在一个单独的线程中执行，是该线程中主要的程序代码段。
异步函数详情
syl的博客
11-07 446
简单来说就是: 当你向服务器请求数据, 等待服务器返回数据需要30s, 这时有两种情况： 1. 等待服务器返回数据，这期间不执行后续代码，等服务器返回数据后在执行后面的代码; 2. 充分利用这等待的30s，t跳过这一步去执行其他的代码，等服务器返回数据了，在回来执行返回数据后的代码; 这第一种情况称为"同步"， 而第二种情况就是"异步";
[Cocoa]_[总结异步调用函数的方法]
yepeng2014的专栏
10-10 1185
总结异步调用函数的方法。  1.dispatch_async  #import int main(int argc, const char * argv[]) { @autoreleasepool { // insert code here... dispatch_async(dispatch_get_global_que
线程池中利用函数指针对任务的动态绑定
豆腐车
07-21 774
最近刚刚接触线程，在网上搜了搜线程池的源码。线程池大致是先创建N个空线程，然后把需要的任务与线程绑定。比较重要的一个数据结构是 struct task { void* (*func) (void* ); void* arg; } 在c语言中凡是涉及动态绑定的时候我总能看到函数指针的身影。 下面是一个测试程序。 #inlcude #include struct task
TCP/IP协议中backlog
KuaiLeShiFu的博客
09-19 475
backlog其实是一个连接队列，以下是backlog队列大小公式。backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列参考：https://www.2cto.com/net/201307/224634.html
回调函数一定是异步调用吗
最新发布
03-27
回调函数不一定是异步调用的，它可以是同步或异步的。回调函数是一种在特定事件发生后被调用的函数，用于处理该事件。在同步调用中，回调函数会在调用者的线程中直接执行，而在异步调用中，回调函数会在另一个线程或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值