vc多線程(qt多線程串口通信)

更新時間:2023-03-01 07:25:34 閱讀：評論：0

VC++多線程問題

據我分析，

1、你的ss因為每個線程都有自己的實例，所以不需要在ss上下臨界區
2、目測你的目的是能夠并行處理 g_runURL 數組里的地址。這樣的話，應該在多個線程間共享那個循環變量i。在創建線程前將i初始化為0，然后將i的地址交給每個線程
3、需要臨界區的地方在于循環里的 i++ 而不是處理過程。故臨界區應該這樣寫：
g_cs.Lock();
for(; i < g_runCount; ++i)
{
int thisi = i; //注意要把在臨界區內訪問到的 i 的值保存在當前線程私有的變量中
g_cs.Unlock();
//這里的代碼用到 i 的要換成 thisi
...//你原來的代碼
g_cs.Lock();
}
g_cs.Unlock();

vc多線程參數傳遞問題

可以這樣做:
為線程參數定義一個結構體
struct
threadParam
{
HANDLE*
lf;
HANDLE*
other;
//還可以定義一些其他你認為需要的參數
};
//假設有2個線程A、B
HANDLE
*HA
=
new
HANDLE;
HANDLE
*HB
=
new
HANDLE;
threadParam
*pA
=
new
threadParam;
PA->lf
=
HA;
PA->other
=
HB;
*HA
=
createthread(NULL,funcA,PA,....);
將PA做為參數傳遞給線程A。這樣就可以在線程函數里通過指針使用a,b的線程句柄了。
同樣創建b線程的時候這樣做一遍就ok。
不知道這樣說明白否？

在VC中，多線程如何調用類得成員函數？

函數內部調用：HANDLE hThread1=CreateThread(NULL,0,Fun1Proc,(LPVOID)this,0,NULL);
HANDLE hThread0=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread,&m_prog,0,NULL);
CloHandle(hThread0);
CloHandle(hThread1);）
Sleep(100);
}

DWORD WINAPI ListenThreadFunc(LPVOID lpParameter)
{
CTestDlg *pDlg=(CTestDlg *)lpParameter;//把傳過來的參數再強制轉換回CTestDlg *類型
pDlg->GetDlgItem(IDC_EDIT1)->SetWindowText("abc");//就可以了
}

thread(CProgressCtrl *pro)//更新進度條
{
int i=0;
for(;i<100;)
{
pro->SetPos(i);
Sleep(200);
i=i+5;
if(i>94)
i=1;
el
;
if(stopmark==1)
{
pro->SetPos(0);
break;
}
}
return 0;
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)//調用程序
{
CCOTSDlg *pDlg=(CCOTSDlg *)lpParameter;//把傳過來的參數再強制轉換回CTestDlg *類型
pDlg->Modeprocess();//就可以了
return 0;
}

控制多線程，開啟、暫停、繼續、終止（實例）
我們這些文盲以前一聽到多線程這么幾個字，以為非常的高級，難搞！！昨天翻閱了一下MSDN，發現，其實也沒那么難，關鍵在于全面的理解，也許是用多了API了，慢慢的會看懂了一些！！！
我總結了幾個易于理解的出來，一起共享！
我們先不講如何使用線程過程中的參數；先來個簡單的；下篇文章我們在講如何使用線程過程的參數來實現交互！
AfxBeginThread　創建線程
　
函數原型：
CWinThread* AfxBeginThread( AFX_THREADPROC pfnThreadProc,
　　LPVOID pParam,
　　int nPriority = THREAD_PRIORITY_NORMAL,
　　UINT nStackSize = 0,
　　DWORD dwCreateFlags = 0,
　　LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL
　　);
該函數用于創建線程；返回值類型為：CWinThread*，一個指向新線程的線程對象
參數：
pfnThreadProc
線程的入口函數,聲明一定要如下: UINT MyThreadFunction( LPVOID pParam );　　
pParam :
傳遞入線程的參數,注意它的類型為:LPVOID,所以我們可以傳遞一個結構體入線程.　
nPriority :
線程的優先級,一般設置為 0 .讓它和主線程具有共同的優先級.　　
nStackSize :
指定新創建的線程的棧的大小.如果為 0,新創建的線程具有和主線程一樣的大小的棧　　
dwCreateFlags :
指定創建線程以后,線程有怎么樣的標志.可以指定兩個值:　　
CREATE_SUSPENDED :
線程創建以后,會處于掛起狀態,直到調用:ResumeThread　　
0 :
創建線程后就開始運行.
　　
lpSecurityAttrs :
指向一個 SECURITY_ATTRIBUTES 的結構體,用它來標志新創建線程的安全性.如果為 NULL ,
　　那么新創建的線程就具有和主線程一樣的安全性.
　　如果要在線程內結束線程,可以在線程內調用 AfxEndThread.
　　結束線程的兩種方式
　　當你在后臺用線程來打印一些圖形時.有時在打印一部分后,你希望可以停下來,那么此如何讓線程停止呢.下
　　面會詳細的向你解釋要結束線程的兩種方式
　　1 : 這是最簡單的方式,也就是讓線程函數執行完成,此時線程正常結束.它會返回一個值,一般0是成功結束,
　　當然你可以定義自己的認為合適的值來代表線程成功執行.在線程內調用AfxEndThread將會直接結束線程,此時線
　　程的一切資源都會被回收.
　　2 : 如果你想讓別一個線程B來結束線程A,那么,你就需要在這兩個線程中傳遞信息.
　　不管是工作者線程還是界面線程,如果你想在線程結束后得到它的確結果,那么你可以調用:
　　::GetExitCodeThread函數
------------------------------------------------------------------------------------------------------------------------
SuspendThread 掛起（暫停）線程
函數原型：
DWORD SuspendThread(
HANDLE hThread //指定線程的句柄
);

這個函數的返回值：DWORD類型，如果這個函數成功,返回值是線程的前停止計數,否則,它(表示)- 1。

-------------------------------------------------------------------------------------------------------------------------------
ResumeThread 繼續執行線程
函數原型：
DWORD ResumeThread(
HANDLE hThread //指定線程的句柄
);

這個函數的返回值：DWORD類型，如果這個函數成功,返回值是線程的前停止計數,否則,它(表示)- 1。

----------------------------------------------------------------------------------------------------------------------------------
WaitForSingleObject 終止線程

　　DWORD WaitForSingleObject(
　　HANDLE hHandle,
　　DWORD dwMilliconds
　　);
　　　　
參數
hHandle
是一個事件的句柄
dwMilliconds
在指定暫停區間,在毫秒。這個函數將返回如果區間流逝,即使該對象的狀態是nonsignaled。如果dwMilliconds是零,功能測試對象的狀態和回報。如果dwMilliconds是INFINITE的,這個函數的暫停區間從不流逝。

VC++ 最簡單的多線程

#include <windows.h>
#include <iostream>
using namespace std;

DWORD WINAPI MyThread1(PVOID pvParam)
{
for(int a=0;a<10;a++)
{
cout<<"Thread1"<<endl;
Sleep(10000);
}
return 0;
}

DWORD WINAPI MyThread2(PVOID pvParam)
{
for(int b=0;b<3;b++)
{
cout<<"Thread2"<<endl;
Sleep(2000);
}
return 0;
}

DWORD WINAPI MyThread3(PVOID pvParam)
{
for(int c=0;c<7;c++)
{
cout<<"Thread3"<<endl;
Sleep(7000);
}
return 0;
}
int main()
{
HANDLE hThread1 = CreateThread(NULL, 0, MyThread1, NULL, 0, NULL);
HANDLE hThread2 = CreateThread(NULL, 0, MyThread2, NULL, 0, NULL);
HANDLE hThread3 = CreateThread(NULL, 0, MyThread3, NULL, 0, NULL);
Sleep(5000);
cout<<"Main"<<endl;
CloHandle(hThread1);
CloHandle(hThread2);
CloHandle(hThread3);
return 0;
}

首先創建一個線程實用API CreateThread , 還有就是一個線程函數的原型.
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpsa,
DWORD cbStack,
LPTHREAD_START_ROUTINE lpStartAddr,
LPVOID lpvThreadParam,
DWORD fdwCreate,
LPDWORD lpIDThread
);

DWORD WINAPI ThreadProc(
[in] LPVOID lpParameter
);

還有就是Sleep這個函數是放棄自己運行的時間片....

VC++ 多線程

你的意思說程序可以同時做2件事,不會因為一件而暫停吧.
下面的代碼就是你說的

// MultipleThread.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "MultipleThread.h"
#include <TChar.h>

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
DialogBox(NULL, MAKEINTRESOURCE(IDD_ABOUTBOX), NULL, About);
return (int) 0;
}

const int MAX_PROCESS_PRIORITY_NUM = 5;
const int MAX_THREAD_PRIORITY_NUM = 6;

TCHAR* pszProcPriorityName[MAX_PROCESS_PRIORITY_NUM] = {L"High", L"Above Normal", L"Normal", L"Below Normal", L"Idle"};
TCHAR* pszThreadPriorityName[MAX_THREAD_PRIORITY_NUM] = {L"High", L"Above Normal", L"Normal", L"Below Normal", L"Lowst", L"Idle"};

int nProcessPriority[MAX_PROCESS_PRIORITY_NUM] = {HIGH_PRIORITY_CLASS, ABOVE_NORMAL_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS,
BELOW_NORMAL_PRIORITY_CLASS, IDLE_PRIORITY_CLASS };

int nThreadPriority[MAX_THREAD_PRIORITY_NUM] = {THREAD_PRIORITY_HIGHEST, THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_BELOW_NORMAL,
THREAD_PRIORITY_LOWEST, THREAD_PRIORITY_IDLE};

HWND hDlg = NULL;

DWORD WINAPI MyThread(PVOID pvParam) //計數線程函數
{
DWORD nCount = 0;
while(nCount ++ < MAXLONG)
{
SetDlgItemInt(hDlg, IDC_EDIT2, nCount, fal);
}
return 0;
}

HANDLE hThread = NULL;

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
ca WM_INITDIALOG:
for(int i = 0; i < MAX_PROCESS_PRIORITY_NUM; i++)
SendDlgItemMessage(hDlg, IDC_COMBO2, CB_ADDSTRING, 0, (LPARAM)pszProcPriorityName[i]);

SendDlgItemMessage(hDlg, IDC_COMBO2, CB_SETCURSEL, 2, 0);

for(int i = 0; i < MAX_THREAD_PRIORITY_NUM; i++)
SendDlgItemMessage(hDlg, IDC_COMBO3, CB_ADDSTRING, 0, (LPARAM)pszThreadPriorityName[i]);

SendDlgItemMessage(hDlg, IDC_COMBO3, CB_SETCURSEL, 2, 0);

hThread = CreateThread(NULL, 0, MyThread, (PVOID)&hDlg, CREATE_SUSPENDED,NULL); //創建一個新的進程

EnableWindow(GetDlgItem(hDlg, IDC_BUTTON3), fal);

::hDlg = hDlg;

SetProcessPriorityBoost(GetCurrentProcess(), fal);
SetThreadPriorityBoost(hThread, fal);

return (INT_PTR)TRUE;

ca WM_COMMAND:
if (HIWORD(wParam) == CBN_SELCHANGE)
{
if(LOWORD(wParam) == IDC_COMBO2)
{
int nIndex = SendDlgItemMessage(hDlg, IDC_COMBO2, CB_GETCURSEL, 0, 0);
SetPriorityClass(GetCurrentProcess(), nProcessPriority[nIndex]);
}
el if(LOWORD(wParam) == IDC_COMBO3)
{
int nIndex = SendDlgItemMessage(hDlg, IDC_COMBO3, CB_GETCURSEL, 0, 0);
SetThreadPriority(hThread, nThreadPriority[nIndex]);
}
return (INT_PTR)TRUE;
}
el if(LOWORD(wParam) == IDC_BUTTON2)
{
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON3), true);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), fal);
ResumeThread(hThread);

MessageBox(hDlg, L"Resume", L"提示", MB_OK);
}
el if(LOWORD(wParam) == IDC_BUTTON3)
{
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), true);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON3), fal);
SuspendThread(hThread);
MessageBox(hDlg, L"Suspend", L"提示", MB_OK);
}
break;

ca WM_CLOSE:
CloHandle(hThread);
ExitProcess(0);
break;
}
return (INT_PTR)FALSE;
}