关于多线程中终止线程的问题

_Meta 2012-09-05 09:17:36
好像看windows程序设计里面说用_beginthread建立一个新进程之后，进程结束时可以不用_endthread，只要ThreadProc执行到了最后或者使用return返回了就会自动处理为这个线程分配的资源。
最近刚接触多线程，不知道各路大神平常是怎么用的啊？上面那样用会不会有内存泄露或者其他问题呀？
...全文
160 11 打赏 收藏 转发到动态 举报
写回复
用AI写文章
11 条回复
切换为时间正序
请发表友善的回复…
发表回复
_Meta 2012-09-06
  • 打赏
  • 举报
 回复
哦，谢谢推荐，好像是本好书啊~

[Quote=引用 10 楼 的回复:]

进程结束会释放malloc、new等申请的内存，关闭打开的文件，打开的Socket，……。
《深入解析Windows操作系统-Windows Internals》之进程管理
[/Quote]
冷月清晖 2012-09-05
  • 打赏
  • 举报
 回复
需要注意的多个线程是共享进程资源的，如果线程退出前没有通知系统资源不再使用了，可能导致其他线程无法使用这些资源。
www_adintr_com 2012-09-05
  • 打赏
  • 举报
 回复
线程结束后线程的堆栈, 线程的局部存储这些肯定是自动回收了的. 但是如果线程的句柄还没有关闭的话, 还会维护一个线程的状态信息. 动态分配的资源不知你指的什么? 你 new 的内存不会自动 delete, 你打开的文件, socket 也不会自动关闭.
_Meta 2012-09-05
  • 打赏
  • 举报
 回复
谢谢！
顺便问下，一个进程结束时，里面所有的线程的所有资源不管是动态分配的还是普通的局部变量应该都会被释放吧？

[Quote=引用 2 楼 的回复:]

建议是使用 _beginthreadex, 尽量不要使用 _beginthread
如果你在线程里面 new 了东西出来, 你还是得自己 delete. 不然就会泄露
[/Quote]
_Meta 2012-09-05
  • 打赏
  • 举报
 回复
哦，呵呵，不过我还在用C啊~
恩，栈里面分配的局部变量都释放了就好，堆里面的数据我会注意的。谢谢啦~

[Quote=引用 1 楼 的回复:]

只要ThreadProc执行到了最后或者使用return返回了就会自动处理为这个线程分配的资源。

这句话是对的。

你在线程函数中new出的内存，记得去delete就可以了。否则会内存泄露。
[/Quote]
www_adintr_com 2012-09-05
  • 打赏
  • 举报
 回复
建议是使用 _beginthreadex, 尽量不要使用 _beginthread
如果你在线程里面 new 了东西出来, 你还是得自己 delete. 不然就会泄露
恨天低 2012-09-05
  • 打赏
  • 举报
 回复
只要ThreadProc执行到了最后或者使用return返回了就会自动处理为这个线程分配的资源。

这句话是对的。

你在线程函数中new出的内存，记得去delete就可以了。否则会内存泄露。
赵4老师 2012-09-05
  • 打赏
  • 举报
 回复
进程结束会释放malloc、new等申请的内存，关闭打开的文件，打开的Socket，……。
《深入解析Windows操作系统-Windows Internals》之进程管理
_Meta 2012-09-05
  • 打赏
  • 举报
 回复
……我想知道进程结束之后会不会释放……动态分配是指C里面的malloc之类的函数申请的内存。

[Quote=引用 4 楼 的回复:]

谢谢！
顺便问下，一个进程结束时，里面所有的线程的所有资源不管是动态分配的还是普通的局部变量应该都会被释放吧？

引用 2 楼 的回复:

建议是使用 _beginthreadex, 尽量不要使用 _beginthread
如果你在线程里面 new 了东西出来, 你还是得自己 delete. 不然就会泄露
[/Quote]
_Meta 2012-09-05
  • 打赏
  • 举报
 回复
……我知道有区别啊……所以还专门在一句话里面把两个词都用上了……
进程结束的时候到底会不会自动释放所有线程在堆和栈里面的所有资源？以前好像看到有在程序结束时还在free的……不知道有没有必要……

[Quote=引用 7 楼 的回复:]

进程和线程不是一回事。
C/C++ code
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#……
[/Quote]
赵4老师 2012-09-05
  • 打赏
  • 举报
 回复
进程和线程不是一回事。
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,

//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，

//在处理的时候每次从新buffer中取两个字节打印

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <windows.h>

#include <process.h>

#include <io.h>

//Log{

#define MAXLOGSIZE 10000000

#define ARRSIZE(x) (sizeof(x)/sizeof(x[0]))

#include <time.h>

#include <sys/timeb.h>

#include <stdarg.h>

char logfilename1[]="MyLog1.log";

char logfilename2[]="MyLog2.log";

char logstr[16000];

char datestr[16];

char timestr[16];

char mss[4];

CRITICAL_SECTION cs_log;

FILE *flog;

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

void LogV(const char *pszFmt,va_list argp) {

    struct tm *now;

    struct timeb tb;



    if (NULL==pszFmt||0==pszFmt[0]) return;

    if (-1==_vsnprintf(logstr,ARRSIZE(logstr),pszFmt,argp)) logstr[ARRSIZE(logstr)-1]=0;

    ftime(&tb);

    now=localtime(&tb.time);

    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);

    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );

    sprintf(mss,"%03d",tb.millitm);

    printf("%s %s.%s %s",datestr,timestr,mss,logstr);

    flog=fopen(logfilename1,"a");

    if (NULL!=flog) {

        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);

        if (ftell(flog)>MAXLOGSIZE) {

            fclose(flog);

            if (rename(logfilename1,logfilename2)) {

                remove(logfilename2);

                rename(logfilename1,logfilename2);

            }

            flog=fopen(logfilename1,"a");

            if (NULL==flog) return;

        }

        fclose(flog);

    }

}

void Log(const char *pszFmt,...) {

    va_list argp;



    Lock(&cs_log);

    va_start(argp,pszFmt);

    LogV(pszFmt,argp);

    va_end(argp);

    Unlock(&cs_log);

}

//Log}

#define ASIZE    200

#define BSIZE    240

#define CSIZE      2

char Abuf[ASIZE];

char Cbuf[CSIZE];

CRITICAL_SECTION cs_HEX ;

CRITICAL_SECTION cs_BBB ;

struct FIFO_BUFFER {

    int  head;

    int  tail;

    int  size;

    char data[BSIZE];

} BBB;

int No_Loop=0;

void HexDump(int cn,char *buf,int len) {

    int i,j,k;

    char binstr[80];



    Lock(&cs_HEX);

    for (i=0;i<len;i++) {

        if (0==(i%16)) {

            sprintf(binstr,"%03d %04x -",cn,i);

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

        } else if (15==(i%16)) {

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

            sprintf(binstr,"%s  ",binstr);

            for (j=i-15;j<=i;j++) {

                sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');

            }

            Log("%s\n",binstr);

        } else {

            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);

        }

    }

    if (0!=(i%16)) {

        k=16-(i%16);

        for (j=0;j<k;j++) {

            sprintf(binstr,"%s   ",binstr);

        }

        sprintf(binstr,"%s  ",binstr);

        k=16-k;

        for (j=i-k;j<i;j++) {

            sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');

        }

        Log("%s\n",binstr);

    }

    Unlock(&cs_HEX);

}

int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {

    int lent,len1,len2;



    lent=0;

    Lock(cs);

    if (fbuf->size>=len) {

        lent=len;

        if (fbuf->head+lent>BSIZE) {

            len1=BSIZE-fbuf->head;

            memcpy(buf     ,fbuf->data+fbuf->head,len1);

            len2=lent-len1;

            memcpy(buf+len1,fbuf->data           ,len2);

            fbuf->head=len2;

        } else {

            memcpy(buf     ,fbuf->data+fbuf->head,lent);

            fbuf->head+=lent;

        }

        fbuf->size-=lent;

    }

    Unlock(cs);

    return lent;

}

void thdB(void *pcn) {

    char        *recv_buf;

    int          recv_nbytes;

    int          cn;

    int          wc;

    int          pb;



    cn=(int)pcn;

    Log("%03d thdB              thread begin...\n",cn);

    while (1) {

        Sleep(10);

        recv_buf=(char *)Cbuf;

        recv_nbytes=CSIZE;

        wc=0;

        while (1) {

            pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);

            if (pb) {

                Log("%03d recv %d bytes\n",cn,pb);

                HexDump(cn,recv_buf,pb);

                Sleep(1);

            } else {

                Sleep(1000);

            }

            if (No_Loop) break;//

            wc++;

            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);

        }

        if (No_Loop) break;//

    }

}

int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {

    int lent,len1,len2;



    Lock(cs);

    lent=len;

    if (fbuf->size+lent>BSIZE) {

        lent=BSIZE-fbuf->size;

    }

    if (fbuf->tail+lent>BSIZE) {

        len1=BSIZE-fbuf->tail;

        memcpy(fbuf->data+fbuf->tail,buf     ,len1);

        len2=lent-len1;

        memcpy(fbuf->data           ,buf+len1,len2);

        fbuf->tail=len2;

    } else {

        memcpy(fbuf->data+fbuf->tail,buf     ,lent);

        fbuf->tail+=lent;

    }

    fbuf->size+=lent;

    Unlock(cs);

    return lent;

}

void thdA(void *pcn) {

    char        *send_buf;

    int          send_nbytes;

    int          cn;

    int          wc;

    int           a;

    int          pa;



    cn=(int)pcn;

    Log("%03d thdA              thread begin...\n",cn);

    a=0;

    while (1) {

        Sleep(100);

        memset(Abuf,a,ASIZE);

        a=(a+1)%256;

        if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop

        send_buf=(char *)Abuf;

        send_nbytes=ASIZE;

        Log("%03d sending %d bytes\n",cn,send_nbytes);

        HexDump(cn,send_buf,send_nbytes);

        wc=0;

        while (1) {

            pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);

            Log("%03d sent %d bytes\n",cn,pa);

            HexDump(cn,send_buf,pa);

            send_buf+=pa;

            send_nbytes-=pa;

            if (send_nbytes<=0) break;//

            Sleep(1000);

            if (No_Loop) break;//

            wc++;

            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);

        }

        if (No_Loop) break;//

    }

}

int main() {

    InitializeCriticalSection(&cs_log );

    Log("Start===========================================================\n");

    InitializeCriticalSection(&cs_HEX );

    InitializeCriticalSection(&cs_BBB );



    BBB.head=0;

    BBB.tail=0;

    BBB.size=0;



    _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);

    _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);



    if (!access("No_Loop",0)) {

        remove("No_Loop");

        if (!access("No_Loop",0)) {

            No_Loop=1;

        }

    }

    while (1) {

        Sleep(1000);

        if (No_Loop) break;//

        if (!access("No_Loop",0)) {

            No_Loop=1;

        }

    }

    Sleep(3000);

    DeleteCriticalSection(&cs_BBB );

    DeleteCriticalSection(&cs_HEX );

    Log("End=============================================================\n");

    DeleteCriticalSection(&cs_log );

    return 0;

}
下载 多线程编程技术开发资料 高清完整PDF版
多线程编程技术开发资料.pdf 个人收集电子书，仅用学习使用，不可用于商业用途，如有版权问题，请联系删除！
多线程的终止方法（停止线程）
多线程的终止方法 多线程的终止共有3种方法 run方法执行结束，正常退出 异常终止 暴力终止 停止线程 停止线程是多线程中的一个重要技术点，本篇文章将对线程的停止操作进行详细讲解。 停止线程不能像for或while循环中使用break停止那样直接，而是需要一些技巧来终止。 如何判断线程已终止 Thread类中提供了两个方法： interrupted()：测试当前线程是否已中断。（静态方法）...
Java 多线程 终止线程的4中方式
多线程 上篇是线程的生命周期，那这次来分享下，终止线程的几种方式。 文章目录多线程1、正常运行结束2. 使用退出标志退出线程3、Interrupt方法结束线程4.stop()方法终止线程（不安全）1.sleep()和wait()区别：2.start()和run()的区别总结 1、正常运行结束 所谓正常运行结束，我的理解就是程序正常运行结束，线程自动结束。 2. 使用退出标志退出线程 一般run()方法执行完，线程就会正常结束，然而腻，常常有些线程是伺服线程。他们需要长时间的运行，只有在外部某些条件满足
python多线程之 终止子线程
中止线程的方法： 1、使用退出标志： 在线程的run方法中根据这个标志位是为true还是为false来判断是否终止，这种情况多用于while循环中。 2、使用 stop() 方法强行终止线程， 但是不推荐使用这个方法，因为使用此方法不安全，目前该方法已被弃用； 3、使用 interrupt()方法中断线程 断线程时并不会立即终止线程，而是通知目标线程，告诉它有人希望你终止。至于目标线程收到通知后会如何处理，则完全由目标线程自行决定。 ...
多线程之终止线程的四种方法
终止线程的四种方法 第一种：正常运行结束 第二种：使用退出标志退出线程 第三种：interrupt()方法退出 第四种：stop方法退出 第一种：正常运行结束 这种就是程序正常执行完run方法或者cell方法然后退出。 第二种：使用退出标志退出线程 一般run方法执行完，线程就会正常结束，但是我们常常有些需求是需要长时间运行的。只有满足某些条件，才能终止这些线程。所以使用一个变量来控制循环，比如最直接方式就是设置一个boolean类型的变量，并且通过设置这个标志为true或者false来控制循环是否退出。
其它技术问题

3,882

社区成员

9,045

社区内容

发帖
与我相关
我的任务
社区描述
C/C++ 其它技术问题
社区管理员
  • 其它技术问题社区
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章