C / C++ / MFC

/*
 * putchar.c
 *
 * Demonstrate use of stdio file locking to generate an "atomic"
 * sequence of character writes (using putchar). If run with an
 * argument of "1", or no argument, the program uses a sequence
 * of putchar_unlocked calls within flockfile/funlockfile to
 * ensure that one threads writes cannot be interleaved with
 * another's.
 *
 * With an argument of "0", the program uses putchar, without
 * file locks, to show that the writes may be interleaved.
 *
 * The putchar[_unlocked] loop is punctuated with sleep(1) calls
 * to ensure that the desired behavior is demonstrated. Without
 * some delay, even on a multiprocessor the program may often
 * fail to display the interleaved output in this simplified
 * case.
 *
 * With file locking, you can expect to see the following output:
 *
 *      thread 1
 *      thread 2
 *      thread 3
 *
 * While without file locking, you can expect to see something
 * much less predictable, but probably resembling this:
 *
 *      ttthhhiiisss   iiisss   ttthhhrrreeeaaaddd   123
 *
 */
#include <pthread.h>
#include "errors.h"

/*
 * This function writes a string (the function's arg) to stdout,
 * by locking the file stream and using putchar_unlocked to
 * write each character individually.
 */
void *lock_routine (void *arg)
{
    char *pointer;

    flockfile (stdout);
    for (pointer = arg; *pointer != '\0'; pointer++) {
        putchar_unlocked (*pointer);
        sleep (1);
    }
    funlockfile (stdout);
    return NULL;
}

/*
 * This function writes a string (the function's arg) to stdout,
 * by using putchar to write each character individually.
 * Although the internal locking of putchar prevents file stream
 * corruption, the writes of various threads may be interleaved.
 */
void *unlock_routine (void *arg)
{
    char *pointer;

    for (pointer = arg; *pointer != '\0'; pointer++) {
        putchar (*pointer);
        sleep (1);
    }
    return NULL;
}

int main (int argc, char *argv[])
{
    pthread_t thread1, thread2, thread3;
    int flock_flag = 1;
    void *(*thread_func)(void *);
    int status;

    if (argc > 1)
        flock_flag = atoi (argv[1]);
    if (flock_flag)
        thread_func = lock_routine;
    else
        thread_func = unlock_routine;
    status = pthread_create (
        &thread1, NULL, thread_func, "this is thread 1\n");
    if (status != 0)
        err_abort (status, "Create thread");
    status = pthread_create (
        &thread2, NULL, thread_func, "this is thread 2\n");
    if (status != 0)
        err_abort (status, "Create thread");
    status = pthread_create (
        &thread3, NULL, thread_func, "this is thread 3\n");
    if (status != 0)
        err_abort (status, "Create thread");
    pthread_exit (NULL);
}

=5790== Thread 3:
==5790== Conflicting load by thread 3 at 0x053fb7e8 size 8
==5790==    at 0x4E4D063: flockfile (in /lib64/libpthread-2.15.so)
==5790==    by 0x4009B6: lock_routine (putchar.c:20)
==5790==    by 0x4C2D231: ??? (in /usr/lib64/valgrind/vgpreload_drd-amd64-linux.so)
==5790==    by 0x4E45E0D: start_thread (pthread_create.c:305)
==5790== Allocation context: BSS section of /lib64/libc-2.15.so
==5790== Other segment start (thread 2)
==5790==    at 0x513E291: clone (clone.S:84)
==5790== Other segment end (thread 2)
==5790==    at 0x510FCAD: ??? (syscall-template.S:82)
==5790==    by 0x510FB50: sleep (sleep.c:138)
==5790==    by 0x4009DB: lock_routine (putchar.c:24)
==5790==    by 0x4C2D231: ??? (in /usr/lib64/valgrind/vgpreload_drd-amd64-linux.so)
==5790==    by 0x4E45E0D: start_thread (pthread_create.c:305)
==5790==
Create thread 3 "putchar.c": 64 Success
t==5790==
==5790== For counts of detected and suppressed errors, rerun with: -v
==5790== ERROR SUMMARY: 2 errors from 1 contexts (suppressed: 38 from 38)

#include<iostream.h>
#include<conio.h>
int main()
{
int a=2;
for (int i=2; i<=20; i++)
{
a=a*a;
}
cout<<a;
getch();
return 0;
}