sched.c

linux下多线程程序设计,包括signals,mutex,simple_once

/********************************************************
 * An example source module to accompany...
 *
 * "Using POSIX Threads: Programming with Pthreads"
 *     by Brad nichols, Dick Buttlar, Jackie Farrell
 *     O'Reilly & Associates, Inc.
 *
 ********************************************************
 * sched.c
 *
 * Examples in setting scheduling policy
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sched.h>
#include <sys/types.h>

#include <pthread.h>

#define NUM_THREADS           3
#define LOOP_COUNT          100000
#define TOTAL_END_COUNT    1000000

#define DEFAULT                 0
#define TIME_SLICE              1
#define FIFO                    2
#define PRIOR                   3
#define PTIME_SLICE             4
#define PFIFO                   5
#define INHERIT                 6

/*
 * Thread initialization 
 */
int threads_ready_count=0;
pthread_cond_t    threads_ready=PTHREAD_COND_INITIALIZER; 
pthread_mutex_t   threads_ready_lock=PTHREAD_MUTEX_INITIALIZER; 

/*
 * Thread progress info
 */
int               total_count=0;
pthread_mutex_t   total_count_lock=PTHREAD_MUTEX_INITIALIZER;
int               thread_counts[NUM_THREADS];


void print_count(int id, int i)
{
	switch(id) 
	{
		case 0:
			printf("print_count()\tthread %d \t%4d\r",id, i++);
			break;
		case 1:
			printf("print_count()\tthread %d \t\t%4d\r",id, i++);
			break;
		case 2:
			printf("print_count()\tthread %d \t\t\t%4d\r",id, i++);
			break;
		case 3:
			printf("print_count()\tthread %d \t\t\t\t%4d\r",id, i++);
			break;
		case 4:
			printf("print_count()\tthread %d \t\t\t\t\t%4d\r",id, i++);
			break;
		case 5:
			printf("print_count()\tthread %d \t\t\t\t\t\t%4d\r",id, i++);
			break;
		default:
			break;
	}
}
void *work_routine(void *arg)
{
	int *my_id=(int *)arg;
	int i=0, not_done=1;
	
	/*
	* The worker threads all wait to begin "together"
	*/
	printf("\nwork_routine()\tthread %d\tI'm Alive\n", *my_id);
	
	pthread_mutex_lock(&threads_ready_lock);
	threads_ready_count++;
	if (threads_ready_count == NUM_THREADS) 
	{
		/* I was the last thread to become ready.  Tell the rest. */
		pthread_cond_broadcast(&threads_ready); 
	}
	else
	{
		/* At least one thread isn't ready.  Wait. */
		while (threads_ready_count != NUM_THREADS) 
		{
			pthread_cond_wait(&threads_ready, &threads_ready_lock);
		}
	}
	pthread_mutex_unlock(&threads_ready_lock);

	/*
	* Enter work loop
	*/
	printf("\nwork_routine()\tthread %d\tI'm Proceeding\n", *my_id);
	
	while(not_done) 
	{
		for (i=0;i < LOOP_COUNT;i++) 
		{
			print_count(*my_id, i++);
		}
		
		thread_counts[*my_id]+=LOOP_COUNT;
		
		/* Check if done */
		pthread_mutex_lock(&total_count_lock);
		if (total_count < TOTAL_END_COUNT)
			total_count+=LOOP_COUNT;
		else
			not_done=0;
		printf("\nwork_routine()\tthread %d\tmy count %d, total_count %d\n", *my_id, thread_counts[*my_id], total_count);
		
		pthread_mutex_unlock(&total_count_lock);
	
	}
	printf("\nworkroutine()\tthread %d\tI'm done\n", *my_id);
	
	return(NULL);
}

extern int main(int argc, char **argv)
{
	int       rtn, t, i, *id_arg, prio_min, prio_max;
	pthread_t threads[NUM_THREADS];
	int       sched = DEFAULT;
	pthread_attr_t pthread_custom_attr;
	struct sched_param priority_param;
	
	
	if ((argc == 2) && (argv[1][0] == 'd')) 
	{
		sched = DEFAULT;
		printf("main()\t\t\t\tTesting Default Scheduling\n");
	}
	if ((argc == 2) && (argv[1][0] == 'r'))  
	{
		sched = TIME_SLICE;
		printf("main()\t\t\t\tTesting Round-Robin Scheduling\n");
	}
	if ((argc == 2) && (argv[1][0] == 'f')) 
	{
		sched = FIFO;
		printf("main()\t\t\t\tTesting FIFO Scheduling\n");
	}
	if ((argc == 2) && (argv[1][0] == 'p')) 
	{
		sched = PFIFO;
		printf("main()\t\t\t\tTesting FIFO/Priority Scheduling\n");
	}
	if ((argc == 2) && (argv[1][0] == 't'))  
	{
		sched = PTIME_SLICE;
		printf("main()\t\t\t\tTesting Round-Robin/Priority Scheduling\n");
	}
	if ((argc == 2) && (argv[1][0] == 'i'))  
	{
		sched = INHERIT;
		printf("main()\t\t\t\tTesting Inherited FIFO Scheduling\n");
	}
	if (argc != 2) 
	{
		printf("Argument required: d=default,r=roundrobin,t=roundrobin/priority,f=fifo,i=inherit,p=fifo/priority\n");
		exit(1);
	}
	
	id_arg = (int *)malloc(NUM_THREADS*sizeof(int));
	
	if (sched != DEFAULT) 
	{
		printf("main() creating a thread with non-default scheduling attributes may\n");
		printf("      require running as root on some platforms.\n");
	}
	
	/* spawn the threads */
	for (i = 0; i < NUM_THREADS; i++) 
	{
	
		id_arg[i] = i;
		thread_counts[i] = 0;
		
		/* set sceduling attributes */
		
		if (sched == DEFAULT) 
		{
			if (pthread_create(&(threads[i]), NULL, work_routine, (void *) &(id_arg[i])) !=0)
				perror("main() pthread create with NULL attr obj failed"),exit(1);
		} 
	    else 
	    {
		
			/*
			* Just for the fun of it, let's up our priority, and 
			* run with policy FIFO
			*/
			
			priority_param.sched_priority = sched_get_priority_max(SCHED_FIFO);
			pthread_setschedparam(pthread_self(), SCHED_FIFO, &priority_param);
			
			if (sched == INHERIT) 
			{
				pthread_attr_init(&pthread_custom_attr);
				pthread_attr_setinheritsched(&pthread_custom_attr, PTHREAD_INHERIT_SCHED);
			} 
			else 
			{
				/*
				* Now, for the rest of the threads
				*/
				pthread_attr_init(&pthread_custom_attr);
				pthread_attr_setinheritsched(&pthread_custom_attr, PTHREAD_EXPLICIT_SCHED);
				if (sched == FIFO) 
				{
					pthread_attr_setschedpolicy(&pthread_custom_attr, SCHED_FIFO);
					prio_min = sched_get_priority_max(SCHED_FIFO); /* PRI_FIFO_MIN;*/
					prio_max = prio_min; /* force to all same priority */
				}
				if (sched == TIME_SLICE) 
				{
					pthread_attr_setschedpolicy(&pthread_custom_attr, SCHED_RR);
					prio_min = sched_get_priority_max(SCHED_RR); /* PRI_RR_MIN; */
					prio_max = prio_min; /* force to all same priority */
				}
				if (sched == PFIFO) 
				{
					pthread_attr_setschedpolicy(&pthread_custom_attr, SCHED_FIFO);
					prio_max = sched_get_priority_max(SCHED_FIFO); /* PRI_FIFO_MAX; */
					prio_min = sched_get_priority_min(SCHED_FIFO); /* PRI_FIFO_MIN; */
				}
				if (sched == PTIME_SLICE) 
				{
					pthread_attr_setschedpolicy(&pthread_custom_attr, SCHED_RR);
					prio_max = sched_get_priority_max(SCHED_RR); /* PRI_RR_MAX; */
					prio_min = sched_get_priority_min(SCHED_RR); /* PRI_RR_MIN; */
				}
				priority_param.sched_priority = prio_min + (i)*(prio_max - prio_min)/(NUM_THREADS-1);
				printf("main()\t\t\t\tsetting priority(%d-%d) of thread %d to %d\n", 
				prio_min, prio_max, i, priority_param.sched_priority);
				if (pthread_attr_setschedparam(&pthread_custom_attr, &priority_param)!=0)
					fprintf(stderr,"pthread_attr_setschedparam failed\n");
			} /* else not inherit */
			
			
			if (pthread_create(&(threads[i]), &pthread_custom_attr, work_routine, (void *) &(id_arg[i])) !=0)
				perror("main() pthread create with attr obj failed"),exit(1);
		
		
		} /* else not default */
	} /* For Num Threads */ 

	printf("\nmain()\t\t\t\t%d threads created. Main running fifo at max\n", NUM_THREADS);
	
	/* wait until all threads have finished */
	for (i = 0; i < NUM_THREADS; i++) 
	{
		if (pthread_join(threads[i], NULL) !=0)
			perror("main() pthread_join failed"),exit(1);
		printf("\nmain()\t\t\t\tjoined to thread %d \n", i);
	}
	
	printf("main()\t\t\t\tall %d threads have finished. \n", NUM_THREADS);
	
	/* Process results */
	printf("main()\t\t\t\ttotal_count %d\n", total_count);
	for (i = 0; i < NUM_THREADS; i++) 
	{
		if (total_count != 0) 
			printf("main()\t\t\t\tthread %d, count %d percent %f\n", i, thread_counts[i], (float)thread_counts[i]/(float)total_count);
	}
	
	return 0;
}