CHIPMAKER

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

// 쓰레드 함수
// 1초를 기다린후 아규먼트^2 을 리턴한다.
void *t_function(void *data)
{
    char a[100000];
    int num = *((int *)data);
printf("Thread Start\n");
    sleep(5);
printf("Thread end\n");
}

int main()
{
    pthread_t p_thread;
    int thr_id;
    int status;
    int a = 100;

    printf("Before Thread\n"); 
    thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a);
    if (thr_id < 0)
    {
        perror("thread create error : ");
        exit(0);
    }

    // 식별번호 p_thread 를 가지는 쓰레드를 detach 
    // 시켜준다.
    pthread_detach(p_thread);
    pause();
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <pthread.h>

static int count = 0;
pthread_attr_t attr[2];

void *threadFunc1(void *arg)
{
	char *s = (char *)arg;
	struct sched_param sched;
	while(1)
	{
		count++;
		printf("%s [%d]\n", s, count);
		pthread_attr_getschedparam(&attr[0], &sched);
		printf("threadFunc1 priority = %d\n", sched.sched_priority); 
		//printf("pthread_self value = %d\n", pthread_self());
		//usleep(100);
	}

	return (void *)strlen(s);
}

void *threadFunc2(void *arg)
{
	char *s = (char *)arg;
	struct sched_param sched;
	while(1)
	{
		count--;
		if(count < 0)
		count = 0;

		printf("%s [%d]\n", s, count);
		pthread_attr_getschedparam(&attr[1], &sched);
		printf("threadFunc2 priority = %d\n", sched.sched_priority);
		//printf("pthread_self value = %d\n", pthread_self());
		//usleep(100);
	}

	return (void *)strlen(s);
}

int main(int argc, char *argv[])
{
	printf("pthread test start !!\n");
	struct sched_param sched;

	pthread_t tid[2];
	void *res;
	int retval;

	pthread_attr_init(&attr[0]);
	pthread_attr_init(&attr[1]);

	pthread_attr_setinheritsched(&attr[0], PTHREAD_EXPLICIT_SCHED);
	pthread_attr_setinheritsched(&attr[1], PTHREAD_EXPLICIT_SCHED);


	printf("Message from main() \n");
	pthread_attr_getschedparam(&attr[0], &sched);
	printf("threadFunc1 priority = %d\n", sched.sched_priority);
	sched.sched_priority = 1;
	pthread_attr_setschedparam(&attr[0], &sched);
	printf("threadFunc1 priority = %d\n", sched.sched_priority);

	pthread_attr_getschedparam(&attr[1], &sched);
	printf("threadFunc2 priority = %d\n", sched.sched_priority);
	sched.sched_priority = 90;
	pthread_attr_setschedparam(&attr[1], &sched);
	printf("threadFunc2 priority = %d\n", sched.sched_priority);

	retval = pthread_create(&tid[0], &attr[0], threadFunc1, "threadFunc1");
	if(retval != 0)
	{
		printf("pthread_create error\n");
	}

	retval = pthread_create(&tid[1], &attr[1], threadFunc2, "threadFunc2");
	if(retval != 0)
	{
		printf("pthread_create error\n");
	}

	retval = pthread_join(tid[0], &res);
	if(retval != 0)
	{
		printf("pthread_join error\n");
	} 

	retval = pthread_join(tid[1], &res);
	if(retval != 0)
	{
		printf("pthread_join error\n");
	} 

	printf("tid[0] = %d Thread returned %ld\n", tid[0], (long) res);
	printf("tid[1] = %d Thread returned %ld\n", tid[1], (long) res);

	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "common.h"

void *SI_ProcessTSFilter(void *pData)
{
	UINT16 PID = 0x00;
	FILE *fp = NULL;
	UINT32 nRead = 0;
	UINT8 buffer[188] = {0, };
	UINT32 filesize = 0;
	
	fp = fopen("hurrycain.ts", "rb");
	if(!fp)
	{
		printf("fopen error \n");
	}
	
	while(1)
	{
		nRead = fread(buffer, 1, 188, fp);

		if(nRead < 188)
			break;
		
		if(buffer[2] == 0)
			printf("TS Header = %#x %#x %#x\n", buffer[0], buffer[1], buffer[2]);
	}
	
	fclose(fp);
	
	pthread_exit(0);
}

int main(int argc, char *argv[])
{
	int opt;
	pthread_t tid;
	pthread_attr_t attr;
	int s;
	
	// Initialize attribute structure
	s = pthread_attr_init(&attr);
	if(s != 0)
	{
		printf("pthread_attr_init error \n");
		exit(1);
	}
	
	s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
	if(s != 0)
	{
		printf("pthread_attr_setdetachstate error \n");
		exit(1);
	}
	
	s = pthread_create(&tid, &attr, SI_ProcessTSFilter, NULL);
	if(s != 0)
	{
		printf("pthread_create error \n");
		exit(1);
	}
	
	s = pthread_attr_destroy(&attr);
	if(s != 0)
	{
		printf("pthread_attr_destory error \n");
		exit(1);
	}

	while((opt = getchar()) != 'q');
	
	return 0;
}

/*
* main.c -- C Test App.
*
* Copyright (C) 2012-2013, 2013 heesoon.kim <chipmaker.tistory.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>

void *threadFunc(void *arg)
{	
	int count = 0;
	printf("new thread started ....\n");
	int retval;
	
#ifdef TEST_PTHREAD_TESTCANCEL
	while(1)
	{
		count++;
		// 임의의 cancle point 지정
		pthread_testcancel();
	};
#else

#ifdef TEST_PTHREAD_SETCANCELSTATE
	retval = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
	if(retval != 0)
	{
		perror("pthread_create : ");
		exit(EXIT_FAILURE);
	}
	
	retval = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
	if(retval != 0)
	{
		perror("pthread_create : ");
		exit(EXIT_FAILURE);
	}	
#endif
	
	while(1)
	{
		printf("count = %d \n", count++);
		sleep(1);
		
		// for testing pthread_exit() return value
		if(count == 10)
			break;
	}
#endif

	pthread_exit((void *) count);	
}

int main(int argc, char *argv[])
{
	pthread_t tid;
	int retval;
	void *res;
	
	retval = pthread_create(&tid, NULL, threadFunc, NULL);
	if(retval != 0)
	{
		perror("pthread_create : ");
		exit(EXIT_FAILURE);
	}
	
	sleep(5);
	
#ifndef EXIT_NORMAL	
	retval = pthread_cancel(tid);
	if(retval != 0)
	{
		perror("pthread_cancle : ");
		exit(EXIT_FAILURE);
	}	
#endif
	
	retval = pthread_join(tid, &res);
	if(retval != 0)
	{
		perror("pthread_join : ");
		exit(EXIT_FAILURE);
	}	
	
	if(res == PTHREAD_CANCELED)
	{
		printf("thread cancled\n");
	}
	else
	{
		printf("thread is normal exit retval = %ld \n", (long)res);
	}
	
	exit(EXIT_SUCCESS);
}