请教一个VC界面多线程 *** 作的例子程序

这是一个多线程例子，里面只有两个线程，是生产者/消费者模式，已编译通过，注释很详细，

如下：

/ 以生产者和消费者模型问题来阐述Linux线程的控制和通信你

生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。

缓冲区有N个，是一个环形的缓冲池。

/

#include <stdioh>

#include <pthreadh>

#define BUFFER_SIZE 16

struct prodcons

{

int buffer[BUFFER_SIZE];/实际存放数据的数组/

pthread_mutex_t lock;/互斥体lock，用于对缓冲区的互斥 *** 作/

int readpos,writepos; /读写指针/

pthread_cond_t notempty;/缓冲区非空的条件变量/

pthread_cond_t notfull;/缓冲区未满 的条件变量/

};

/初始化缓冲区/

void pthread_init( struct prodcons p)

{

pthread_mutex_init(&p->lock,NULL);

pthread_cond_init(&p->notempty,NULL);

pthread_cond_init(&p->notfull,NULL);

p->readpos = 0;

p->writepos = 0;

}

/将产品放入缓冲区，这里是存入一个整数/

void put(struct prodcons p,int data)

{

pthread_mutex_lock(&p->lock);

/等待缓冲区未满/

if((p->writepos +1)%BUFFER_SIZE ==p->readpos)

{

pthread_cond_wait(&p->notfull,&p->lock);

}

p->buffer[p->writepos] =data;

p->writepos++;

if(p->writepos >= BUFFER_SIZE)

p->writepos = 0;

pthread_cond_signal(&p->notempty);

pthread_mutex_unlock(&p->lock);

}

/从缓冲区取出整数/

int get(struct prodcons p)

{

int data;

pthread_mutex_lock(&p->lock);

/等待缓冲区非空/

if(p->writepos == p->readpos)

{

pthread_cond_wait(&p->notempty ,&p->lock);//非空就设置条件变量notempty

}

/读书据，移动读指针/

data = p->buffer[p->readpos];

p->readpos++;

if(p->readpos == BUFFER_SIZE)

p->readpos = 0;

/设置缓冲区未满的条件变量/

pthread_cond_signal(&p->notfull);

pthread_mutex_unlock(&p->lock);

return data;

}

/测试：生产站线程将1 到1000的整数送入缓冲区，消费者线程从缓冲区中获取整数，两者都打印信息/

#define OVER (-1)

struct prodcons buffer;

void producer(void data)

{

int n;

for( n=0;n<1000;n++)

{

printf("%d ------>\n",n);

put(&buffer,n);

}

put(&buffer,OVER);

return NULL;

}

void consumer(void data)

{

int d;

while(1)

{

d = get(&buffer);

if(d == OVER)

break;

else

printf("----->%d\n",d);

}

return NULL;

}

int main()

{

pthread_t th_p,th_c;

void retval;

pthread_init(&buffer);

pthread_create(&th_p,NULL,producer,0);

pthread_create(&th_c,NULL,consumer,0);

/等待两个线程结束/

pthread_join(th_p, &retval);

pthread_join(th_c,&retval);

return 0;

}

线程的回调函数本是一个全局或静态的函数，他不能 *** 作其他类中的数据，在线程回调函数中定义类的对象也只能使用共有成员，

如果定义一个全局的变量的话就未免没必要，

你可以这样，

你在创建线程的时候，创线程的函数中除了回调函数参数，还有另一个参数是作为传进线程里面的参数，当你需要 *** 作类中的成员，就把那他的地址做为参数，或着直接就把类的this指针做参数，这样你在回调函数中就可以直接 *** 作回调函数的参数，就是 *** 作你建线程时候给的参数，

但在回调函数中要进行强制转换，

就是你线程函数中的那个LPVOID类型的参数，用来转换。

当然，你还可以用向主窗口发送消息的方式去使主窗口的数据有改变，

比如自定消息和处理函数，在处理函数中写你需要做的事情，而这个事情是由线程来触发的，这样不就可以线程处理数据了

关键是 lpOnRecvCardEvent 这个函数的第二个参数是个 C++ 指针。

楼主在 C# 中声明这个导出函数时，使用了并不对应的 CardEvent[] C# 数组类型。

正确的做法是： 在 C# 声明 lpOnRecvCardEvent 时，第二个参数应该是 IntPtr ，不是数组。

由于楼主的这个 VC DLL 可能是自己写的，我没办法给出正确代码。

我提供一份模拟代码做参考：

----------------------------------------------------------------------------------------------------

VC DLL:

StructModh

#pragma once

#include <Windowsh>

#ifndef STRUCTMOD_EXPORT

#define STRUCTMOD_EXPORT extern "C" __declspec(dllimport)

#endif

typedef struct _tagCardEvent {

DWORD CardNo;

INT32 EvtYear;

} CardEvent, PCardEvent;

STRUCTMOD_EXPORT CardEvent;

STRUCTMOD_EXPORT PCardEvent;

typedef void CALLBACK PFNTEST(PCardEvent pce, INT32 nEvt);

STRUCTMOD_EXPORT void Caller(PFNTEST pfnTest);

StructModcpp

#define STRUCTMOD_EXPORT extern "C" __declspec(dllexport)

#include "StructModh"

#include <tcharh>

void Caller(PFNTEST pfnTest) {

CardEvent ce[2] = , };

if (pfnTest) (pfnTest)(ce, _countof(ce));

}

--------------------------------------------------------------------------------------------------------------------

C# 调用：

using System;

using SystemText;

using SystemRuntimeInteropServices;

namespace IntPtrTest

{

class Program

{

static void Main(string[] args)

{

TestD t = new TestD(Test);

Caller(t);

}

[StructLayout(LayoutKindSequential)]

public struct CardEvent

{

public uint CardNo;

public Int32 EvtYear;

}

delegate void TestD(IntPtr p, Int32 nEvt);

[DllImport("StructMod", EntryPoint = "Caller", CallingConvention = CallingConventionCdecl)]

private static extern void Caller(TestD t);

public static unsafe void Test(IntPtr p, Int32 nEvt)

{

ConsoleWriteLine("nEvt = " + nEvtToString() + EnvironmentNewLine);

for (int n = 0; n < nEvt; n++)

{

p = p + n sizeof(CardEvent);

CardEvent ce = (CardEvent)MarshalPtrToStructure(p, typeof(CardEvent));

ConsoleWriteLine("[]", n);

ConsoleWriteLine("CardNo - " + ceCardNoToString());

ConsoleWriteLine("EvtYear - " + ceEvtYearToString());

}

}

}

}

回调函数的主要作用：

1回调函数就是本模块实现的回调函数，但是调用却不是自己来调，而是由别的模块来调的

2可更好的把握调用函数的时机，

回调函数依赖对应注册回调的模块，回调函数由该模块触发，触发的条件、时间点，都是由该模块控制

（通常由该模块的事件消息，触发）

3在不同模块间进行使用，可令触发逻辑与业务逻辑分离，让代码功能性上更为清晰，易懂

注意点：

回调函数跑的事情，都是在触发回调的线程下进行的，如果回调函数中干很多事，很容易造成触发模块-所属线程堵塞

这对于多线程编程时，需特别注意，线程堵塞，会影响其他线程运行时序，造成一些bug

通常用法：

以库的形式，供别人调用实现

以上是根据网上相应资料，再加上自己的总结体会，整理出来的

下面是自己写的一个回调函数-用法的例子：

主要 分成2个模块

A模块为定义回调函数的模块，负责触发回调，一般为事件消息模块

B模块为实现回调函数的模块，一般为处理业务逻辑模块

A模块需向B模块暴露定义及注册回调接口

typedef void (TestCB)(char testData);

void A_SetTestCb(TestCB pTestCb)

B模块实现具体的回调函数就可以了，本例中即B_UserTestCbDetail(char testData)

主要分3步：注册回调函数->消息事件触发回调函数->执行回调函数

附代码：

#include "stdioh"

//定义回调函数-别名,方便后续使用------需提供给模块B

typedef void (TestCB)(char testData);

//模块A内部的全局回调变量,用于模块A内部绑定注册回调用

TestCB g_pTestCbHandle;

/

模块A对外函数---------需提供给模块B

模块A内部定义的全局callback变量与外部模块注册的

回调函数绑定起来,用于后续模块A,满足触发条件后,触

发回调

/

void A_SetTestCb(TestCB pTestCb)

{

g_pTestCbHandle = pTestCb;

}

/

模块A内部函数

通常为A模块因为某些条件符合了,触发了对应的事件

从而调用对应的callback函数

/

void A_CallTestCb()

{

char testData = 100;

//触发调用回调实现函数

g_pTestCbHandle(testData);

}

/

模块B内部函数

模块B实现的回调函数-具体 *** 作

/

void B_UserTestCbDetail(char testData)

{

printf("step 3\n");

printf("[do] call-back\n");

//具体实现

printf("UserTestCbDetail, call back is achieve! testData = %d\n", testData);

}

void main()

{

printf("step 1\n");

printf("[register] call-back\n");

A_SetTestCb(B_UserTestCbDetail);

printf("step 2\n");

printf("[call] call-back\n");

A_CallTestCb();

}

要copy出去，或者 ReceiveData直接声明成 char[] 然后 sio_read(2,ReceiveData,10)算了。

你这个代码里 ibuf是在栈上的，一旦退出程序这部分内存就回收了，再试图使用当然出错

你能写ReceiveData=(CString)ibuf; 难道不是说可以用这个变量么？。。