Return to suspend.c CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Example of DOSSUSPENDTHREAD/DOSRESUMETHREAD usage.
        !             3:  *
        !             4:  * DOSSUSPENDTHREAD can be used to ensure mutual exclusion when a thread
        !             5:  * knows by number all the other thread which might try to access the
        !             6:  * shared resource.
        !             7:  * 
        !             8:  * In this example the main thread can call printf() freely because it
        !             9:  * knows that the only other thread has been suspended, so the main
        !            10:  * thread will not be interrupted, and because it knows that the
        !            11:  * subthread must have been suspended while outside of a critical
        !            12:  * section, and so the main thread will not be interrupting the
        !            13:  * subthread's call to vio.
        !            14:  * 
        !            15:  * Any thread may suspend any other thread in its process, including the
        !            16:  * main thread and itself.  If a thread suspends all the threads in a
        !            17:  * process, including itself, then deadlock will result, and the process
        !            18:  * will have to be killed externally.
        !            19:  *
        !            20:  * Note that there are three methods for managing critical sections
        !            21:  * amongst threads in a process:
        !            22:  *
        !            23:  *     1. Semaphores - this is almost always the right solution
        !            24:  *     2. DosEnterCritSec
        !            25:  *     3. DosSuspendThread
        !            26:  *
        !            27:  * compile as: cl -Gs -AL -G2 -Lp suspend.c
        !            28:  *
        !            29:  */
        !            30: 
        !            31: #include <doscalls.h>
        !            32: #include <subcalls.h>
        !            33: #include "stdio.h"
        !            34: #include "malloc.h"
        !            35: #define STACK_SIZE     1024
        !            36: 
        !            37: extern void f_thread(void);
        !            38: int flag;
        !            39: 
        !            40: void main()
        !            41: {
        !            42:        char *stkptr;
        !            43:        unsigned thread_id;
        !            44:        register int i;
        !            45:        
        !            46:        /* obtain pointer to the END of a block of memory */
        !            47:        stkptr = (char *)malloc(STACK_SIZE) + STACK_SIZE - 1;
        !            48:        
        !            49:        /* create another thread */
        !            50:        DOSCREATETHREAD(f_thread, &thread_id, stkptr);
        !            51:        
        !            52:        for(i = 0; i < 20; i++) {
        !            53:                DOSSUSPENDTHREAD(thread_id);    /* suspend the subthread */
        !            54:        
        !            55:                printf("the main thread has suspended thread %u\n", thread_id);
        !            56:                DOSSLEEP(3000L);
        !            57:        
        !            58:                /* resume the subthread */
        !            59:                printf("now resuming the suspended thread\n");
        !            60:                DOSRESUMETHREAD(thread_id);
        !            61: 
        !            62:                DOSSLEEP(3000L);
        !            63:        }
        !            64:        DOSEXIT(1, 0);          /* exit all threads */
        !            65: }
        !            66: 
        !            67: void f_thread()
        !            68: {
        !            69:        while (1) {
        !            70:                DOSENTERCRITSEC();
        !            71:                VIOWRTTTY("subthread running\r\n", 19, 0);
        !            72:                DOSEXITCRITSEC();
        !            73:                DOSSLEEP(300L);
        !            74:        }
        !            75: }

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