Return to dosexit.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / examples / dosexit

Annotation of os2sdk/demos/examples/dosexit/dosexit.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Example of DOSEXIT usage.
        !             3:  *
        !             4:  * DOSEXIT can be used to terminate a specific thread, or all threads in
        !             5:  * a process. In general, even if your application has just one thread
        !             6:  * it is very important to use the "all threads" form of DOSEXIT when
        !             7:  * your application terminates. This is because you may call some library
        !             8:  * package or run under an environment manager which creates threads on
        !             9:  * your behalf, which you are not aware of.
        !            10:  *
        !            11:  * In this example, the main thread is the first to call DOSEXIT, but calls it
        !            12:  * so as to only end the one thread. Whichever of the two remaining threads
        !            13:  * first notices that the flag has been set will then call DOSEXIT and
        !            14:  * terminate the process.  If f_thread is the one to call DOSEXIT then
        !            15:  * the process will return an exit code of 1, and if it is g_thread, an
        !            16:  * exit code of 2.
        !            17:  *
        !            18:  * compile as: cl -Gs -AL -G2 -Lp dosexit.c
        !            19:  *
        !            20:  * Copyright (C) Microsoft Corp. 1986
        !            21:  *
        !            22:  */
        !            23: 
        !            24: #include <malloc.h>
        !            25: #include <doscalls.h>
        !            26: #include <subcalls.h>
        !            27: 
        !            28: #define STACK_SIZE     1024
        !            29: extern void f_thread(void);
        !            30: extern void g_thread(void);
        !            31: int flag;
        !            32: 
        !            33: main()
        !            34: {
        !            35:        char *stkptr;
        !            36:        unsigned thread_id;
        !            37:        
        !            38:        flag = 0;
        !            39: 
        !            40:        /* create two subthreads */
        !            41:        stkptr = (char *)malloc(STACK_SIZE) + STACK_SIZE;
        !            42:        DOSCREATETHREAD(f_thread, &thread_id, stkptr);
        !            43:        
        !            44:        stkptr = (char *)malloc(STACK_SIZE) + STACK_SIZE;
        !            45:        DOSCREATETHREAD(g_thread, &thread_id, stkptr);
        !            46:        
        !            47:        /* let the sub-threads run for a while */
        !            48:        DOSSLEEP(500L);
        !            49:        
        !            50:        /* exit from this thread only */
        !            51:        printf("main thread is now exiting\n");
        !            52:        flag = 1;
        !            53:        DOSEXIT(0,0);
        !            54: }
        !            55: 
        !            56: void f_thread()
        !            57: {
        !            58:        /* wait for the global flag to be set */
        !            59:        while (flag == 0) {
        !            60:                VIOWRTTTY("f_thread, still running\r\n", 25, 0);
        !            61:                DOSSLEEP(0L);
        !            62:        }
        !            63:        
        !            64:        /* exit this process (all threads) */
        !            65:        VIOWRTTTY("f_thread, now exiting all\r\n", 27, 0);
        !            66:        DOSEXIT(1,1);
        !            67: }
        !            68: 
        !            69: void g_thread()
        !            70: {
        !            71:        /* wait for the global flag to be set */
        !            72:        while (flag == 0) {
        !            73:                VIOWRTTTY("g_thread, still running\r\n", 25, 0);
        !            74:                DOSSLEEP(0L);
        !            75:        }
        !            76:        
        !            77:        /* exit this process (all threads) */
        !            78:        VIOWRTTTY("g_thread, now exiting all\r\n", 27, 0);
        !            79:        DOSEXIT(1,2);
        !            80: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.