linux 프로그램 설계 프로세스 및 스레드 학습

프로세스: 프로그램 코드 + 데이터 + 변수 (시스템 메모리를 차지함) + 파일 설명자 (열린 파일) + 환경 p408 알람시계alarm을 시뮬레이션합니다.c 루틴: 새로운 실행 루틴은 자신의 창고에 국부 변수를 저장하지만 그의 창설자와 전역 변수, 파일 설명자, 신호 처리 함수, 현재 디렉터리 상태를 공유합니다.

#include 
#include 
#include 
#include //pause  
#include 

static int alarm_fired = 0;//  

void ding(int sig)//    ，     
{
	alarm_fired = 1;//    ，    1
}

//        5      SIGALRM  (    )      
int main()
{
	pid_t pid;
	printf("alarm application atarting
");
	
	pid = fork();//     
	switch(pid){
	case -1:
		perror("fork failed");
		exit(1);
	case 0:
		//child
		sleep(5);//       
		kill(getppid(),SIGALRM);//              
		exit(0);
	}

	//       signal            ，           
	//         ding   printf，       ， main   printf      
	printf("waiting for alarm to go off
");
	(void) signal(SIGALRM, ding);
	
	pause();//       ，           ,        

	if(alarm_fired)
		printf("Ding!
");
	printf("Done
");
	exit(0);
}

//               

//          sigaction  signal
#include 
#include 
#include 

void ouch(int sig)
{
	printf("OUCH! - I got signal %d
", sig);
}

int main()
{
	struct sigaction act;//  ：      、     、  

	act.sa_handler = ouch;
	sigemptyset(&act.sa_mask);//         :          ，          ，         
	act.sa_flags = 0;
	sigaction(SIGINT, &act, 0);

	while(1){
		printf("Hello world!
");
		sleep(1);
	}
}

//Ctrl + C   ：    
//  ：Ctrl+\   

신호량: 같은 그룹의 대상에 대한 접근을 제어할 수 있다. 예를 들어 5개의 사용 가능한 전화선에서 1개를 특정한 라인에 분배하는 경우 계수 신호량을 사용하기에 더욱 적합하다.상호 배척량: 공유 메모리에 접근할 수 있는 라인이 한 시간만 있을 수 있도록 제어합니다
예: 키보드에서 입력한 문자열의 개수를 신호량과 이중 라인으로 통계한다

#include 
#include 
#include 
#include 
#include 
#include  //       

const int WORK_SIZE = 1024;

void *thread_function(void *arg);
sem_t bin_sem; //   
char work_area[WORK_SIZE];

int main()
{
    int res;
    pthread_t a_thread;
    void *thread_result; //         

    //          ，     0,        ,sem_wait                0 
    //int sem_init(sem_t *sem, int pshared, unsigned int value);
    //pshared:       ，０                
    res = sem_init(&bin_sem, 0, 0);

    if (res != 0)
    {
        perror("Semaphore initialization failed");
        exit(EXIT_FAILURE);
    }

    res = pthread_create(&a_thread, NULL, thread_function, NULL); //         ,      

    if (res != 0)
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }

    printf("Input some text.Enter 'end' to finish
");
    while (strncmp("end", work_area, 3) != 0)
    {
        fgets(work_area, WORK_SIZE, stdin); //         
        sem_post(&bin_sem);                 //       ,   ,     0,     ,      ,              
    }

    printf("
Waiting for thread to finish...
");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0)
    {
        perror("Thread join failed");
        exit(EXIT_FAILURE);
    }
    printf("Thread joined
");
    sem_destroy(&bin_sem);
    exit(EXIT_SUCCESS);
}

void *thread_function(void *arg)
{ //   :     ,           
    sem_wait(&bin_sem);
    while (strncmp("end", work_area, 3) != 0)
    {
        printf("You input %d characters
", strlen(work_area) - 1);
        sem_wait(&bin_sem);
    }
    pthread_exit(NULL);
}

개선: 주 스레드가 통계 스레드가 문자열 개수의 통계를 완성한 후에 계속 실행하도록 합니다. 상호 배척량을 사용할 수 있습니다.
상호 배율로 동기화
대상을 잠그면 매번 한 라인만 접근할 수 있습니다.

#include 
#include 
#include 
#include 
#include 

#include 

//              
#define WORK_SIZE 1024
char work_area[WORK_SIZE];
pthread_mutex_t work_mutex; //protects both work_area and time_to_exit
int time_to_exit = 0;

void *thread_function(void *arg);

int main()
{
    int res;
    pthread_t a_thread;
    void *thread_result;

    res = pthread_mutex_init(&work_mutex, NULL); //      ,      
    if (res != 0)
    {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }

    res = pthread_create(&a_thread, NULL, thread_function, NULL); //    
    if (res != 0)
    {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
    }

    pthread_mutex_lock(&work_mutex); //  ,         ,             
    printf("Input some text.Enter 'end' to finish
");
    while (!time_to_exit) //    end,         
    {
        fgets(work_area, WORK_SIZE, stdin);
        if (work_area[0] != '\0')
        {
            pthread_mutex_unlock(&work_mutex); //            
            sleep(1);
        }
        else
        {
            break;
        }
    }
    pthread_mutex_unlock(&work_mutex);
}

void *thread_function(void *arg) //         
{
    sleep(1);
    pthread_mutex_lock(&work_mutex); //     ,           
    while (strncmp("end", work_area, 3) != 0)
    {
        printf("You input %d characters
", (int)strlen(work_area) - 1); //     ,    

        work_area[0] = '\0';               //        NULL,             
        pthread_mutex_unlock(&work_mutex); //  ,        ,    
        sleep(1);
        pthread_mutex_lock(&work_mutex); //          
        while (work_area[0] == '\0')     //           ,      
        {
            pthread_mutex_unlock(&work_mutex); //       
            sleep(1);
            pthread_mutex_lock(&work_mutex);
        }
    }
    //end   ,         
    time_to_exit = 1;
    work_area[0] = '\0';
    pthread_mutex_unlock(&work_mutex);
    pthread_exit(0);
}
//note:          ,      ,                        ,   ,