#include <pthread.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>



#define QUEUESIZE 10

#define LOOP 20



void *producer (void *args);

void *consumer (void *args);



typedef struct {

	int buf[QUEUESIZE];

	long head, tail;

	int full, empty;

	pthread_mutex_t *mut;

	pthread_cond_t *notFull, *notEmpty;

} queue;



queue *queueInit (void);

void queueDelete (queue *q);

void queueAdd (queue *q, int in);

void queueDel (queue *q, int *out);



int main ()

{

	queue *fifo;

	pthread_t pro, con;



	fifo = queueInit ();

	if (fifo ==  NULL) {

		fprintf (stderr, "main: Queue Init failed.\n");

		exit (1);

	}

	pthread_create (&pro, NULL, producer, fifo);

	pthread_create (&con, NULL, consumer, fifo);

	pthread_join (pro, NULL);

	pthread_join (con, NULL);

	queueDelete (fifo);



	return 0;

}



void *producer (void *q)

{

	queue *fifo;

	int i;



	fifo = (queue *)q;



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

		pthread_mutex_lock (fifo->mut);

		while (fifo->full) {

			printf ("producer: queue FULL.\n");

			pthread_cond_wait (fifo->notFull, fifo->mut);

		}

		queueAdd (fifo, i);

		pthread_mutex_unlock (fifo->mut);

		pthread_cond_signal (fifo->notEmpty);

		usleep (100000);

	}

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

		pthread_mutex_lock (fifo->mut);

		while (fifo->full) {

			printf ("producer: queue FULL.\n");

			pthread_cond_wait (fifo->notFull, fifo->mut);

		}

		queueAdd (fifo, i);

		pthread_mutex_unlock (fifo->mut);

		pthread_cond_signal (fifo->notEmpty);

		usleep (200000);

	}

	return (NULL);

}



void *consumer (void *q)

{

	queue *fifo;

	int i, d;



	fifo = (queue *)q;



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

		pthread_mutex_lock (fifo->mut);

		while (fifo->empty) {

			printf ("consumer: queue EMPTY.\n");

			pthread_cond_wait (fifo->notEmpty, fifo->mut);

		}

		queueDel (fifo, &d);

		pthread_mutex_unlock (fifo->mut);

		pthread_cond_signal (fifo->notFull);

		printf ("consumer: recieved %d.\n", d);

		usleep(200000);

	}

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

		pthread_mutex_lock (fifo->mut);

		while (fifo->empty) {

			printf ("consumer: queue EMPTY.\n");

			pthread_cond_wait (fifo->notEmpty, fifo->mut);

		}

		queueDel (fifo, &d);

		pthread_mutex_unlock (fifo->mut);

		pthread_cond_signal (fifo->notFull);

		printf ("consumer: recieved %d.\n", d);

		usleep (50000);

	}

	return (NULL);

}



#ifdef 0

typedef struct {

	int buf[QUEUESIZE];

	long head, tail;

	int full, empty;

	pthread_mutex_t *mut;

	pthread_cond_t *notFull, *notEmpty;

} queue;

#endif



queue *queueInit (void)

{

	queue *q;



	q = (queue *)malloc (sizeof (queue));

	if (q == NULL) return (NULL);



	q->empty = 1;

	q->full = 0;

	q->head = 0;

	q->tail = 0;

	q->mut = (pthread_mutex_t *) malloc (sizeof (pthread_mutex_t));

	pthread_mutex_init (q->mut, NULL);

	q->notFull = (pthread_cond_t *) malloc (sizeof (pthread_cond_t));

	pthread_cond_init (q->notFull, NULL);

	q->notEmpty = (pthread_cond_t *) malloc (sizeof (pthread_cond_t));

	pthread_cond_init (q->notEmpty, NULL);

	

	return (q);

}



void queueDelete (queue *q)

{

	pthread_mutex_destroy (q->mut);

	free (q->mut);	

	pthread_cond_destroy (q->notFull);

	free (q->notFull);

	pthread_cond_destroy (q->notEmpty);

	free (q->notEmpty);

	free (q);

}



void queueAdd (queue *q, int in)

{

	q->buf[q->tail] = in;

	q->tail++;

	if (q->tail == QUEUESIZE)

		q->tail = 0;

	if (q->tail == q->head)

		q->full = 1;

	q->empty = 0;



	return;

}



void queueDel (queue *q, int *out)

{

	*out = q->buf[q->head];



	q->head++;

	if (q->head == QUEUESIZE)

		q->head = 0;

	if (q->head == q->tail)

		q->empty = 1;

	q->full = 0;



	return;

}

//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,

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

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

#ifdef WIN32

    #pragma warning(disable:4996)

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef WIN32

    #include <windows.h>

    #include <process.h>

    #include <io.h>

    #define  MYVOID             void

    #define  vsnprintf          _vsnprintf

#else

    #include <unistd.h>

    #include <sys/time.h>

    #include <pthread.h>

    #define  CRITICAL_SECTION   pthread_mutex_t

    #define  MYVOID             void *

#endif

//Log{

#define MAXLOGSIZE 20000000

#define MAXLINSIZE 16000

#include <time.h>

#include <sys/timeb.h>

#include <stdarg.h>

char logfilename1[]="MyLog1.log";

char logfilename2[]="MyLog2.log";

static char logstr[MAXLINSIZE+1];

char datestr[16];

char timestr[16];

char mss[4];

CRITICAL_SECTION cs_log;

FILE *flog;

#ifdef WIN32

void Lock(CRITICAL_SECTION *l) {

    EnterCriticalSection(l);

}

void Unlock(CRITICAL_SECTION *l) {

    LeaveCriticalSection(l);

}

void sleep_ms(int ms) {

    Sleep(ms);

}

#else

void Lock(CRITICAL_SECTION *l) {

    pthread_mutex_lock(l);

}

void Unlock(CRITICAL_SECTION *l) {

    pthread_mutex_unlock(l);

}

void sleep_ms(int ms) {

    usleep(ms*1000);

}

#endif

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

    struct tm *now;

    struct timeb tb;



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

    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);

    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);

            }

        } else {

            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;

}

MYVOID 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_ms(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_ms(1);

            } else {

                sleep_ms(1000);

            }

            if (No_Loop) break;//

            wc++;

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

        }

        if (No_Loop) break;//

    }

#ifndef WIN32

    pthread_exit(NULL);

#endif

}

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;

}

MYVOID 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_ms(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_ms(1000);

            if (No_Loop) break;//

            wc++;

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

        }

        if (No_Loop) break;//

    }

#ifndef WIN32

    pthread_exit(NULL);

#endif

}

int main() {

#ifdef WIN32

    InitializeCriticalSection(&cs_log);

    InitializeCriticalSection(&cs_HEX );

    InitializeCriticalSection(&cs_BBB );

#else

    pthread_t threads[2];

    int threadsN;

    int rc;

    pthread_mutex_init(&cs_log,NULL);

    pthread_mutex_init(&cs_HEX,NULL);

    pthread_mutex_init(&cs_BBB,NULL);

#endif

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



    BBB.head=0;

    BBB.tail=0;

    BBB.size=0;



#ifdef WIN32

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

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

#else

    threadsN=0;

    rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);

    rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);

#endif



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

        remove("No_Loop");

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

            No_Loop=1;

        }

    }

    while (1) {

        sleep_ms(1000);

        if (No_Loop) break;//

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

            No_Loop=1;

        }

    }

    sleep_ms(3000);

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

#ifdef WIN32

    DeleteCriticalSection(&cs_BBB );

    DeleteCriticalSection(&cs_HEX );

    DeleteCriticalSection(&cs_log);

#else

    pthread_mutex_destroy(&cs_BBB);

    pthread_mutex_destroy(&cs_HEX);

    pthread_mutex_destroy(&cs_log);

#endif

    return 0;

}