A. c语言多线程如何运行指定时间
第一步： 将源文件1（1.c)修改为如下形式： #include "print.h" #include "2.c" int main(void) { printHello(); return 0; } 其中的2.c就是源文件2的文件名 第二步，将三个文件保存到同一目录中 第三步，打开TC2，执行FILE-CHANGE DIR，将工作目录换到三个文件所在的目录。 第四步，在TC2中打开1.c文件，编译运行。 建议不要再使用TC2这个相对原始的IDE了，上面介绍的这个方法也并不是标准方法，建议使用TC2006/VC/BCB等现代的IDE环境，如果实在是舍弃不下DOS字符界面，那就试试GCC吧！
B. c语言如何编写一个简单的多线程程序
这是一个多线程例子，里面只有两个线程，是生产者/消费者模式，已编译通毁举宏过，注释很详细，x0dx0a如下：x0dx0ax0dx0a/* 以生答蠢产者和消费者模型问题来阐述Linux线程的控制和通信你 x0dx0a 生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。x0dx0a 缓冲区有N个，是一个环形的缓冲池。x0dx0a */纤册x0dx0a#include
C. c语言 多线程套接字编程
你ip的初始值是多少？
有没有重定向过标准输入？
另一个线程是否也阻塞在读标准输入上？
D. win32程序创建线程用c语言库的_beginthread还是API的CreateThread哪种用的多
让我们简单回顾一下历史。很早以前，是一个库用于单线程应用程序，另一个库用于多线程应
用程序。之所以采用这个设计，是由于标准C运行库是在1970年左右发明的。要在很久很久之
后，才会在操作系统上出现线程的概念。标准C运行库的发明者根本没有考虑到为多线程应用
程序使用C运行库的问题。让我们用一个例子来了解可能遇到的问题。
以标准C运行库的全局变量errno为例。有的函数会在出错时设置该变量。假定现在有这样的一
个代码段：
BOOL fFailure = (system("NOTEPAD.EXE README.TXT") == -1);
if (fFailure) {
switch (errno) {
case E2BIG: // Argument list or environment too big
break;
case ENOENT: // Command interpreter cannot be found
break;
case ENOEXEC: // Command interpreter has bad format
break;
case ENOMEM: // Insufficient memory to run command
break;
}
}
假设在调用了system函数之后，并在执行if语句之前，执行上述代码的线程被中断了。另外还假
设，这个线程被中断后，同一个进程中的另一个线程开始执行，而且这个新线程将执行另一个
C运行库函数，后者设置了全局变量errno。当CPU后来被分配回第一个线程时，对于上述代码
中的system函数调用，errno反映的就不再是正确的错误码。为了解姿告枣决这个问题，每个线程都需
要它自己的errno变量。此外，必须有某种机制能够让一个线程引用它自己的errno变量，同时
不能让它去碰另一个线程的errno变量。
这仅仅是证明了“标准C/C++运行库最初不是为多线程应用程序而设计”的众多例子中的一个。
在多线程环境中会出问题的C/C++运行库变量和函数有errno，_doserrno，strtok，_wcstok，
strerror，_strerror，tmpnam，tmpfile，asctime，_wasctime，gmtime，_ecvt和_fcvt等等。
为了保证C和C++多线程应用程序正常运行，必须创建一个数据结构，并使之与使用了C/C++运
行库函数的每个线程关联。然后，在调用C/C++运行库函数时，那些函数必须知道去查找主调
线程的数据块，从而避免影响到其他线程。
那么，系统在创建新的线程时，是如何知道要分配这个数据块的呢？答案是它并不知道。系统
并不知道应用程序是用C/C++来写的，不知道你调用的函数并非天生就是线程迹拆安全的。保证线
程安全是程序员的责任。创建新线程时，一定不要调用操作系统的CreateThread函数。相反，
必须调友亮用C/C++运行库函数_beginthreadex：
unsigned long _beginthreadex(
void *security,
unsigned stack_size,
unsigned (*start_address)(void *),
void *arglist,
unsigned initflag,
unsigned *thrdaddr);
_beginthreadex函数的参数列表与CreateThread函数的一样，但是参数名称和类型并不完全一
样。这是因为Microsoft的C/C++运行库开发组认为，C/C++运行库函数不应该对Windows数据类
型有任何依赖。_beginthreadex函数也会返回新建线程的句柄，就像CreateThread那样。所以，
如果已经在自己的源代码中调用了CreateThread函数，可以非常方便地用_beginthreadex来全
局替换所有CreateThread。但是，由于数据类型并不完相同，所以可能还必须执行一些类型转
换，以便顺利地通过编译。为了简化这个工作，我创建了一个名为chBEGINTHREADEX的宏，
并在自己的源代码中使用：
typedef unsigned (__stdcall *PTHREAD_START) (void *);
#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr, \
pvParam, fdwCreate, pdwThreadID) \
((HANDLE) _beginthreadex( \
(void *) (psa), \
(unsigned) (cbStackSize), \
(PTHREAD_START) (pfnStartAddr), \
(void *) (pvParam), \
(unsigned) (dwCreateFlags), \
(unsigned *) (pdwThreadID)))
根据Microsoft为C/C++运行库提供的源代码，很容易看出_beginthreadex能而CreateThread不能
做的事情。事实上，在搜索了Visual Studio安装文件夹后，我在<Program Files>\Microsoft Visual
Studio 8\VC\crt\src\Threadex.c中找到了_beginthreadex的源代码。为节省篇幅，这里没有全部照
抄一遍。相反，我在这里提供了该函数的伪代码版本，强调了其中最有意思的地方：
uintptr_t __cdecl _beginthreadex (
void *psa,
unsigned cbStackSize,
unsigned (__stdcall * pfnStartAddr) (void *),
void * pvParam,
unsigned dwCreateFlags,
unsigned *pdwThreadID) {
_ptiddata ptd; // Pointer to thread's data block
uintptr_t thdl; // Thread's handle
// Allocate data block for the new thread.
if ((ptd = (_ptiddata)_calloc_crt(1, sizeof(struct _tiddata))) == NULL)
goto error_return;
// Initialize the data block.
initptd(ptd);
// Save the desired thread function and the parameter
// we want it to get in the data block.
ptd->_initaddr = (void *) pfnStartAddr;
ptd->_initarg = pvParam;
ptd->_thandle = (uintptr_t)(-1);
// Create the new thread.
thdl = (uintptr_t) CreateThread((LPSECURITY_ATTRIBUTES)psa, cbStackSize,
_threadstartex, (PVOID) ptd, dwCreateFlags, pdwThreadID);
if (thdl == 0) {
// Thread couldn't be created, cleanup and return failure.
goto error_return;
}
// Thread created OK, return the handle as unsigned long.
return(thdl);
error_return:
// Error: data block or thread couldn't be created.
// GetLastError() is mapped into errno corresponding values
// if something wrong happened in CreateThread.
_free_crt(ptd);
return((uintptr_t)0L);
}
对于_beginthreadex函数，以下几点需要重点关注。
每个线程都有自己的专用_tiddata内存块，它们是从C/C++运行库的堆（heap）上分配
的。
传给_beginthreadex的线程函数的地址保存在_tiddata内存块中。(_tiddata结构在
Mtdll.h文件的C++源代码中。)纯粹是为了增加趣味性，我在下面重现了这个结构。要
传入_beginthreadex函数的参数也保存在这个数据块中。
_beginthreadex确实会在内部调用CreateThread，因为操作系统只知道用这种方式来
创建一个新线程。
CreateThread函数被调用时，传给它的函数地址是_threadstartex（而非
pfnStartAddr）。另外，参数地址是_tiddata结构的地址，而非pvParam。
如果一切顺利，会返回线程的句柄，就像CreateThread那样。任何操作失败，会返回0。
struct _tiddata {
unsigned long _tid; /* thread ID */
unsigned long _thandle; /* thread handle */
int _terrno; /* errno value */
unsigned long _tdoserrno; /* _doserrno value */
unsigned int _fpds; /* Floating Point data segment */
unsigned long _holdrand; /* rand() seed value */
char* _token; /* ptr to strtok() token */
wchar_t* _wtoken; /* ptr to wcstok() token */
unsigned char* _mtoken; /* ptr to _mbstok() token */
/* following pointers get malloc'd at runtime */
char* _errmsg; /* ptr to strerror()/_strerror() buff */
wchar_t* _werrmsg; /* ptr to _wcserror()/__wcserror() buff */
char* _namebuf0; /* ptr to tmpnam() buffer */
wchar_t* _wnamebuf0; /* ptr to _wtmpnam() buffer */
char* _namebuf1; /* ptr to tmpfile() buffer */
wchar_t* _wnamebuf1; /* ptr to _wtmpfile() buffer */
char* _asctimebuf; /* ptr to asctime() buffer */
wchar_t* _wasctimebuf; /* ptr to _wasctime() buffer */
void* _gmtimebuf; /* ptr to gmtime() structure */
char* _cvtbuf; /* ptr to ecvt()/fcvt buffer */
unsigned char _con_ch_buf[MB_LEN_MAX];
/* ptr to putch() buffer */
unsigned short _ch_buf_used; /* if the _con_ch_buf is used */
/* following fields are needed by _beginthread code */
void* _initaddr; /* initial user thread address */
void* _initarg; /* initial user thread argument */
/* following three fields are needed to support signal handling and runtime errors */
void* _pxcptacttab; /* ptr to exception-action table */
void* _tpxcptinfoptrs;/* ptr to exception info pointers */
int _tfpecode; /* float point exception code */
/* pointer to the of the multibyte character information used by the thread */
pthreadmbcinfo ptmbcinfo;
/* pointer to the of the locale information used by the thread */
pthreadlocinfo ptlocinfo;
int _ownlocale; /* if 1, this thread owns its own locale */
/* following field is needed by NLG routines */
unsigned long _NLG_dwCode;
/*
* Per-Thread data needed by C++ Exception Handling
*/
void* _terminate; /* terminate() routine */
void* _unexpected; /* unexpected() routine */
void* _translator; /* S.E. translator */
void* _purecall; /* called when pure virtual happens */
void* _curexception; /* current exception */
void* _curcontext; /* current exception context */
int _ProcessingThrow; /* for uncaught_exception */
void* _curexcspec; /* for handling exceptions thrown from std::unexpected */
#if defined (_M_IA64) || defined (_M_AMD64)
void* _pExitContext;
void* _pUnwindContext;
void* _pFrameInfoChain;
unsigned __int64 _ImageBase;
#if defined (_M_IA64)
unsigned __int64 _TargetGp;
#endif /* defined (_M_IA64) */
unsigned __int64 _ThrowImageBase;
void* _pForeignException;
#elif defined (_M_IX86)
void* _pFrameInfoChain;
#endif /* defined (_M_IX86) */
_setloc_struct _setloc_data;
void* _encode_ptr; /* EncodePointer() routine */
void* _decode_ptr; /* DecodePointer() routine */
void* _reserved1; /* nothing */
void* _reserved2; /* nothing */
void* _reserved3; /* nothing */
int _ cxxReThrow; /* Set to True if it's a rethrown C++ Exception */
unsigned long __initDomain; /* initial domain used by _beginthread[ex] for managed
function */
};
typedef struct _tiddata * _ptiddata;
为新线程分配并初始化_tiddata结构之后，接着应该知道这个结构是如何与线程关联的。来看看
_threadstartex函数(它也在C/C++运行库的Threadex.c文件中)。下面是我为这个函数及其helper
函数__callthreadstartex编写的伪代码版本：
static unsigned long WINAPI _threadstartex (void* ptd) {
// Note: ptd is the address of this thread's tiddata block.
// Associate the tiddata block with this thread so
// _getptd() will be able to find it in _callthreadstartex.
TlsSetValue(__tlsindex, ptd);
// Save this thread ID in the _tiddata block.
((_ptiddata) ptd)->_tid = GetCurrentThreadId();
// Initialize floating-point support (code not shown).
// call helper function.
_callthreadstartex();
// We never get here; the thread dies in _callthreadstartex.
return(0L);
}
static void _callthreadstartex(void) {
_ptiddata ptd; /* pointer to thread's _tiddata struct */
// get the pointer to thread data from TLS
ptd = _getptd();
// Wrap desired thread function in SEH frame to
// handle run-time errors and signal support.
__try {
// Call desired thread function, passing it the desired parameter.
// Pass thread's exit code value to _endthreadex.
_endthreadex(
( (unsigned (WINAPI *)(void *))(((_ptiddata)ptd)->_initaddr) )
( ((_ptiddata)ptd)->_initarg ) ) ;
}
__except(_XcptFilter(GetExceptionCode(), GetExceptionInformation())){
// The C run-time's exception handler deals with run-time errors
// and signal support; we should never get it here.
_exit(GetExceptionCode());
}
}
关于_threadstartex函数，要注意以下重点：
新的线程首先执行RtlUserThreadStart (在NTDLL.dll文件中)，然后再跳转到
_threadstartex。
_threadstartex惟一的参数就是新线程的_tiddata内存块的地址。
TlsSetValue是一个操作系统函数，它将一个值与主调线程关联起来。这就是所谓的线
程本地存储(Thread Local Storage，TLS)，详情参见第21章。_threadstartex函数将
_tiddata内存块与新建线程关联起来。
在无参数的helper函数_callthreadstartex中，一个SEH帧将预期要执行的线程函数包围
起来。这个帧处理着与运行库有关的许多事情——比如运行时错误(如抛出未被捕捉的
C++异常)——和C/C++运行库的signal函数。这一点相当重要。如果用CreateThread函
数新建了一个线程，然后调用C/C++运行库的signal函数，那么signal函数不能正常工作。
预期要执行的线程函数会被调用，并向其传递预期的参数。前面讲过，函数的地址和
参数由_beginthreadex保存在TLS的_tiddata数据块中；并会在_callthreadstartex中从
TLS中获取。
线程函数的返回值被认为是线程的退出代码。
注意_callthreadstartex不是简单地返回到_threadstartex，继而到RtlUserThreadStart；
如果是那样的话，线程会终止运行，其退出代码也会被正确设置，但线程的_tiddata
内存块不会被销毁。这会导致应用程序出现内存泄漏。为防止出现这个问题，会调用
_endthreadex（也是一个C/C++运行库函数），并向其传递退出代码。
最后一个需要关注的函数是_endthreadex(也在C运行库的Threadex.c文件中)。下面是我编写的该
函数的伪代码版本：
void __cdecl _endthreadex (unsigned retcode) {
_ptiddata ptd; // Pointer to thread's data block
// Clean up floating-point support (code not shown).
// Get the address of this thread's tiddata block.
ptd = _getptd_noexit ();
// Free the tiddata block.
if (ptd != NULL)
_freeptd(ptd);
// Terminate the thread.
ExitThread(retcode);
}
对于_endthreadex函数，要注意几下几点：
C运行库的_getptd_noexit函数在内部调用操作系统的TlsGetValue函数，后者获取主调
线程的tiddata内存块的地址。
然后，此数据块被释放，调用操作系统的ExitThread函数来实际地销毁线程。当然，
退出代码会被传递，并被正确地设置。
在本章早些时候，我曾建议大家应该避免使用ExitThread函数。这是千真万确的，而且我在这
里并不打算自相矛盾。前面说过，此函数会杀死主调线程，而且不允许它从当前执行的函数返
回。由于函数没有返回，所以构造的任何C++对象都不会被析构。现在，我们又有了不调用
ExitThread函数的另一个理由：它会阻止线程的_tiddata内存块被释放，使应用程序出现内存泄
漏（直到整个进程终止）。
Microsoft的C++开发团队也意识到，总有一些开发人员喜欢调用ExitThread。所以，他们必须
使这成为可能，同时尽可能避免应用程序出现内存泄漏的情况。如果真的想要强行杀死自己的
线程，可以让它调用_endthreadex(而不是ExitThread)来释放线程的_tiddata块并退出。不过，
我并不鼓励你调用_endthreadex。
现在，你应该理解了C/C++运行库函数为什么要为每一个新线程准备一个独立的数据块，而且
应该理解了_beginthreadex如何分配和初始化此数据块，并将它与新线程关联起来。另外，你还
应理解了_endthreadex函数在线程终止运行时是如何释放该数据块的。
一旦这个数据块被初始化并与线程关联，线程调用的任何需要“每线程实例数据”的C/C++运
行库函数都可以轻易获取主调线程的数据块的地址(通过TlsGetValue)，并操纵线程的数据。这
对函数来说是没有问题的。但是，对于errno之类的全局变量，它又是如何工作的呢？errno是在
标准C headers中定义的，如下所示：
_CRTIMP extern int * __cdecl _errno(void);
#define errno (*_errno())
int* __cdecl _errno(void) {
_ptiddata ptd = _getptd_noexit();
if (!ptd) {
return &ErrnoNoMem;
} else {
return (&ptd->_terrno);
}
}
任何时候引用errno，实际都是在调用内部的C/C++运行库函数_errno。该函数将地址返回给“与
主调线程关联的数据块”中的errno数据成员。注意，errno宏被定义为获取该地址的内容。这
个定义是必要的，因为很可能写出下面这样的代码：
int *p = &errno;
if (*p == ENOMEM) {
...
}
如果内部函数_errno只是返回errno的值，上述代码将不能通过编译。
C/C++运行库还围绕特定的函数放置了同步原语（synchronization primitives）。例如，如果两个
线程同时调用malloc，堆就会损坏。C/C++运行库函数阻止两个线程同时从内存堆中分配内存。
具体的办法是让第2个线程等待，直至第1个线程从malloc函数返回。然后，才允许第2个线程进
入。(线程同步将在第8章和第9章详细讨论。)显然，所有这些额外的工作影响了C/C++运行库的
多线程版本的性能。
C/C++运行库函数的动态链接版本被写得更加泛化，使其可以被使用了C/C++运行库函数的所有
运行的应用程序和DLL共享。因此，库只有一个多线程版本。由于C/C++运行库是在一个DLL
中提供的，所以应用程序(.exe文件)和DLL不需要包含C/C++运行库函数的代码，所以可以更小
一些。另外，如果Microsoft修复了C/C++运行库DLL的任何bug，应用程序将自动获得修复。
就像你期望的一样，C/C++运行库的启动代码为应用程序的主线程分配并初始化了一个数据块。
这样一来，主线程就可以安全地调用任何C/C++运行库函数。当主线程从其入口函数返回的时
候，C/C++运行库函数会释放关联的数据块。此外，启动代码设置了正确的结构化异常处理代
码，使主线程能成功调用C/C++运行库的signal函数。
6.7.1 用_beginthreadex 而不要用CreateThread 创建线程
你可能会好奇，假如调用CreateThread而不是C/C++运行库的_beginthreadex来创建新线程，会
发生什么呢？当一个线程调用一个需要_tiddata结构的C/C++运行库函数时，会发生下面的情
况。(大多数C/C++运行库函数都是线程安全的，不需要这个结构。)首先，C/C++运行库函数尝
试取得线程数据块的地址(通过调用TlsGetValue)。如果NULL被作为_tiddata块的地址返回，表
明主调线程没有与之关联的_tiddata块。在这个时候，C/C++运行库函数会为主调线程分配并初
始化一个_tiddata块。然后，这个块会与线程关联(通过TlsSetValue) ，而且只要线程还在运行，
这个块就会一直存在并与线程关联。现在，C/C++运行库函数可以使用线程的_tiddata块，以后
调用的任何C/C++运行库函数也都可以使用。
当然，这是相当诱人的，因为线程（几乎）可以顺畅运行。但事实上，问题还是有的。第一个
问题是，假如线程使用了C/C++运行库的signal函数，则整个进程都会终止，因为结构化异常处
理（SEH）帧没有就绪。第二个问题是，假如线程不是通过调用_endthreadex来终止的，数据
块就不能被销毁，从而导致内存泄漏。(对于一个用CreateThread函数来创建的线程，谁会调用
_endthreadex呢？)
E. C语言多线程的优势
线程程序作为一种多任务、并发的工作方式，当然有其存在优势：
提高应用程序响应：
这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
使多CPU系统更加有效：
操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
改善程序结构：
一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
F. 用C语言写多线程程序
thread_creation.c
gcc thread_creation.c
会在当前目录山配行下逗哗，生成可执行卖袭的a.out文件
./a.out
G. c语言怎么同时运行4段
可以使用多线程的办法，同时运行的方法如下：
1）使用void*myfunc（void*args）{；
2）在intmain(){limian写四组pthread，pthread_create(),pthread_join()；
3)最后return0。
多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。
程序语言有多种分类方法，大部分程序语言都是算法描述型语言，如C/C++、Java等，还有一部分是数据描述型语言，如HTML等标记语言。按照编程技术难易程度可分为低级语言(机器语言、汇编语言)和高级语言；按照程序语言设计风格可分为命令式语言(过程化语言)、结构化语言、面向对象语言、函数式语言、脚本语言等；按照语言应用领域可分为通用程序语言(GPPL)和专用程序语言(DSL)；按照程序执行方式，可分为解释型语言(如JavaScript、Python、Perl、R等)，编译型语言(如C/C++等)，编译+解释型语言(如Java、PHP等)。
H. C语言中 怎么实现双线程 或者 父子线程啊
运行一个程序，这个运行实体就是一个“进程”。
例如，用鼠标双击IE浏览器的图标，你运行了一个IE“进程”。第一个窗未关，你又用鼠标双击IE浏览器的图标，又出来一个浏览器的窗。这时，你运行了同一个程序的两个进程。
对于自己写的程序也如此。运行它，这个运行实体就是一个“进程”。同时运行两个，就是两个进程。计算机分别对两个进程分配资源，直到进程结束，收回资源。
线程是进程里真真跑的线路，真真执行的运算，每个进程有一个主线程。进程里可以开第二第三条新的执行线路，gcc 用 pthread_create()，VC++ 用 CreateThread(), 这就叫双线程和多线程。进程是线程的容器，同一进程的线程共享它们进程的资源。线程里建的线程就是父子线程。
两个或多个进程协同工作时，需要互相交换信息，有些情况下进程间交换的少量信息，有些情况下进程间交换大批信息。这就要通讯。通讯方式不止一种。管道就是一种。VC++ 用 CreatePipe() 函数建立。
管道的实质是一个共享文件，可借助于文件系统的机制实现，创建、打开、关闭和读写.
一个进程正在使用某个管道写入或读出数据时，另一个进程就必须等待. 发送者和接收者双方必须知道对方是否存在，如果对方已经不存在，就没有必要再发送信息.,发送信息和接收信息之间要协调，当写进程把一定数量的数据写入管道，就去睡眠等待，直到读进程取走数据后，把它唤醒。
VC++ 线程例子：
#include <windows.h>
#include <iostream.h>
DWORD WINAPI fun1(LPVOID lp);
DWORD WINAPI fun2(LPVOID lp);
int piao=500;
int main()
{
HANDLE pthread1,pthread2;
pthread1=CreateThread(0,0,fun1,0,0,0);
pthread2=CreateThread(0,0,fun2,0,0,0);
CloseHandle(pthread1);
CloseHandle(pthread2);
Sleep(3000);
return 0;
}
DWORD WINAPI fun1(LPVOID lp)
{
while(1)
{
if(piao>0)
cout<< "thread-1-"<< piao--<<endl;
else
break;
}
return 0;
}
DWORD WINAPI fun2(LPVOID lp)
{
while(1)
{
if(piao>0)
cout<<"thread-2-"<<piao--<<endl;
else
break;
}
return 0;
}
===================================
建管道函数原形：
BOOL CreatePipe(
PHANDLE hReadPipe, // read handle
PHANDLE hWritePipe, // write handle
LPSECURITY_ATTRIBUTES lpPipeAttributes, // security attributes
DWORD nSize // pipe size
);
I. 用C语言如何实现多线程同时运行的情况下，各个线程输出不同的随机数
1、使用pthread库执行多线程，这个是Linux下的线程库 Windows下应该有自己的API，不过这种东西一般还是以Linux为标准。pthread_create()创建一个线程，传入橘态搭fun()的函数指针就行了。然后这个Beep()的需求要进行线程间通信，可以用共享内存的方法，设一个bool变量flag共享，然后beep的时候设为false，beep完设成true。fun()里面每次看一下这个flag，是false的话就不做动作等下一闭启秒，基本可以满足需求。
2、例程：
#include<pthread.h>
#include<stdio.h>
#include<sys/time.h>
#include<string.h>
#defineMAX10
pthread_tthread[2];
pthread_mutex_tmut;
intnumber=0,i;
void*thread1()
{
printf("thread1:I'mthread1 ");
for(i=0;i<MAX;i++)
{
printf("thread1:number=%d ",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(2);
}
printf("thread1:主函数在等我完成任务吗？ ");
pthread_exit(NULL);
}
void*thread2()
{
printf("thread2:I'mthread2 ");
for(i=0;i<MAX;i++)
{
printf("thread2:number=%d ",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(3);
}
printf("thread2:主函数在等我完成任务吗？ ");
pthread_exit(NULL);
}
voidthread_create(void)
{
inttemp;
memset(&thread,0,sizeof(thread));//comment1
/*创建线程*/
if((temp=pthread_create(&thread[0],NULL,thread1,NULL))!=0)//comment2
printf("线程1创建失败! ");
else
printf("线程1被创建 ");
if((temp=pthread_create(&thread[1],NULL,thread2,NULL))!=0)//comment3
printf("线程2创建失败");
else
printf("线程2被创建 ");
}
voidthread_wait(void)
{
/*等待线程结束*/
if(thread[0]!=0){//comment4
pthread_join(thread[0],NULL);
printf("线程1已经结束 ");
}
if(thread[1]!=0){//comment5
pthread_join(thread[1],NULL);
printf("线程2已经结束 ");
}
}
intmain()
{
/*用默认属性初始化互斥锁圆拿*/
pthread_mutex_init(&mut,NULL);
printf("我是主函数哦，我正在创建线程，呵呵 ");
thread_create();
printf("我是主函数哦，我正在等待线程完成任务阿，呵呵 ");
thread_wait();
return0;
}
J. windows环境，多线程情况下，C语言向文件写入数据。
①、对于你能写这么长的问题描述，说明你很认真。
②、你的目的性较强，但是你也想有更加明确的目标，我可以给你讲一下怎么自己去寻找目标和路线以及怎样学习。
③、计算机专业领域一共有几个大方向，十几个分支方向，而每个分支方向又有几十个小方向，每一个方向的深入学习与熟练到一定火候都不是一朝一夕，互相之间也不是完全没联系的，但是你现在就应该选择一个大方向并在其中的一个小方向内深入（为什么要这么早就选择具体的分支方向？后面说）。
④、这里列出计算机的几个大方向（非编程开发类的我就不说了）：
基本方向：
1、单片机、嵌入式方向
2、网络编程：涉及到服务器程序、客户端开发、脚本设计等。
3、系统编程：基础API开发、桌面开发、系统程序开发、服务程序
4、图形学：3D、2D、图像识别、人脸识别
5、音频：语音识别、音频解码、音频软件
6、编译原理：编译器设计、脚本解释器、虚拟机、非自然语言翻译系统
7、应用层开发：利用高层语言去开发表层应用
8、安全：反工程、病毒、反病毒、木马、反木马、软件破解、软件加壳
附加方向：
8、人工智能：遗传算法、神经网络、灰色系统等等
9、游戏设计：各种游戏引擎设计以及业务逻辑设计等
⑤、基本方向是你一定要选的，附加方向只是基于基本方向的一些锦上添花，但是不管你怎么选，最开始某些东西一定要深入而不是只是懂就够（当然你对自己要求似乎不会很低），我把这个列出来：
数据结构：下面其他理论的基础。
操作系统原理：理解操作系统的架构和细节，你才能对以后关于多线程、文件管理、内存管理、指令优先级等有一个正确理解和运用。
编译原理：能够升华你对计算机编程语言的理解，对以后出现的各种编译、解释、兼容、移植、优化、并发与并行算法等有一个深入理解。
数据库系统原理：这个是进入公司都要会的，也是大型软件开发的基础。
软件工程：这个是你能够在经验不足还能保证大项目正常完成的理论基础。
网络技术：这个是必须学的，因为目前几乎没有一款装几率很高的软件或者平台跟网络无关。
数学的话，主要是：离散数学、线性代数、高等数学、计算机图形学、概率论
以上几个基础就是你成为一个融汇各个主要分支牛人必须学的（当然不是指理论，而是理论+实践编码能力）
⑥以上都是大的基础，要一一攻破并深入学习，虽然网络时代计算机专业知识爆炸式的增长，但是以上几个基础掌握后，会发现，以后的什么新的理论和技术都是基于这些大基础，你就很容易理解了。
⑦我为什么开头不讲你要具体学什么怎么顺序学呢？因为那些技术你要掌握的话，根本可以自己解决，但是如果你由于兴趣，沉迷于一些自己可见的小范围技术的话，那么毕业后虽然也能找到不错的工作，薪水也可能高，但是不能成为一个大牛。
现在才开始讲学习顺序，虽然你说不要推荐书，不过我还是要用书来做顺序。
C语言是可以写很多核心和高级的东西，而不只是小东西，但是从你代码来看，居然用到了 goto，我不是说你那些程序用到GOTO有什么不好，而是一定要避免用GOTO，goto是错误之源，如果你有什么内容非要用到goto才能写到，说明你的编码技巧还有不少提高空间。
你的学习顺序应该是：
C：做一个超级马里奥出来，并能够读取文本脚本来更新关卡。
C++：写一个2D图形引擎，封装掉细节，实现面向对象设计和可复用设计，并且用到《设计模式》中提到的一些设计模式，这样才能算对C++有一个很好的掌握。
MFC：MFC技术虽然近期已经冷下来了，但是你能熟练掌握它，才能证明你的C++OO技术够纯熟，严格证明你掌握了MFC很简单，你只要用MFC做出一个杀毒引擎就差不多了。推荐的书有《深入浅出MFC》。
《Windows程序设计》：和MFC不同的是，用的是windows核心SDK,也就是API，这本书学完后，你才能从操作系统层面上算掌握了win32 平台下的机理（其实win64和win32大部分机理类似）。
C#：C#里集合了当代和前沿计算机科学里最先进的一些语法（虽然执行效率一直被人质疑），但是你学完C#并深入后，至少能够算是对计算机语言有一个更加深刻的理解了。如何证明你C#学的不错了？也很简单，再次写一个随便什么游戏，比如俄罗斯方块。如果更加证明自己呢？用它写一个P2P网络对战游戏。
（如果你注意的话，会发现我说的学习顺序都是沿着语言和某些技术的，为什么呢？因为这些语言和技术涉及到特定的领域技术和计算机理论思想，比如学完了C#的话，就不单指学完了C#，而是把多种语言范式都学习了一遍，以及现代的程序开发思维（因为里面用到了很多让你一劳永逸的技术））
以上5个步骤都是基础大步骤，要解决的话要没1-2年应该不够。
与此同时，要尽快选出文中你感兴趣的方向作为3-5年的长期方向，不要担心过早选择分支方向会有什么损失，因为计算机很多分支是相通的，只有你把分支方向深入进去，才能真正理解很多理论的实践意义。并且一旦你在某个分支领域形成了较强的优势（比如，到公司里只有你这方面最强），那么你就是稀缺人才。
关于大方向的步骤就不说了，你主要就是要把我说的这几个基础步骤先解决，同时平时要注重大方向理论结合实际去编码和开发。