Главная    Разработка ПО    функции языка Си

Описание функций языка Си

" P "

perror 

pow,powf,powl 

pow10,pow10f,pow10l 

printf 

pthread_attr_getdetachstate 

pthread_attr_getinheritsched 

pthread_attr_getschedparam 

pthread_attr_getschedpolicy 

pthread_attr_init 

putc 

putchar 

puts 

putw 

   

All | _ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

pthread_attr_getdetachstate – опрос атрибута потока управления «статус освобождения ресурсов».

Синтаксис:

#include < pthread.h >
int pthread_attr_getdetachstate ( const pthread_attr_t *attr, int *detach);

Аргументы:

attr – указатель на описатель атрибутов потока; detach – указатель на переменную, в которую будет записано значение считанного атрибута;

Возвращаемое значение:

0 – при успешном завершении работы функции, иначе - код ошибки EINVAL – указатель attr не корректен (атрибуты потока не проинициализированы)

Описание:

Функция pthread_attr_getdetachstate () копирует в переменную, на которую указывает аргумент detach, атрибут потока «статус освобождения ресурсов (описателя потока)». До копирования атрибуты потока должны быть проинициализированы с помощью функции pthread_attr_init.

Считанный атрибут может принимать два значения:

PTHREAD_CREATE_DETACHED – описатель потока управления будет автоматически освобожден (может использоваться для создания другого потока) сразу же по завершению потока.

PTHREAD_CREATE_JOINABLE – после завершения потока управления, описатель не будет освобожден то тех пор, пока какой-либо другой поток управления не получит код окончания данного потока с помощью функции pthread_join().

Пример 1:

В примере инициализируется описатель атрибутов потока, считываются и выводятся в консоль установленные по умолчанию атрибуты, затем атрибуты потока изменяются на следующие:

- освобождать ресурсы (описатель) потока автоматически,
- стратегия планирования FIFO,
- приоритет 50,
- стратегия планирования определяется атрибутами потока,
- размер стека 16 мб,
- буфер защиты стека от переполнения - 8 кб,
- область конкурирования – все потоки процесса.

Далее создается поток управления, в рамках которого работает функция pthread_func, которая в течении 5-ти секунд, с темпом раз в секунду, вводит сообщения о работе потока (счетчик циклов). Затем поток завершается и завершается работа программы.

При компиляции программы, работающей с потоками управления, необходимо использовать ключ –lpthread. Так, например, для компиляции файла test.c с исходным текстом приведенным в примере 1, и создания объектного файла ts.o необходимо в консоле, в папке с файлом test.c, набрать команду: gcc test.c -o ts -lpthread


#include < stdio.h >   // Для printf
#include < pthread.h > // Для функций работы с потоками

// Функция, запускаемая в рамках потока управления
void pthread_func (void);

int main (void)
{
   // Создаем структура для хранения атрибутов потока управления
   pthread_attr_t attr;
   // Переменная в которую будет записан описатель атрибутов потока
   pthread_t new_pthread;

   // Устанавливаем стандартные атрибуты потока, если стандартные 
   // атрибуты не установлены, то выводим сообщение об ошибке и
   // завершаем работу
   printf ("\nУстановка стандартных атрибутов потока управления: ");
   if (0== pthread_attr_init (&attr))
      printf ("OK\n");
   else
      { printf ("Error"); return -1; }


   // Определение атрибутов потока управления по умолчанию
   printf ("Определение атрибутов потока управления:\n");

   // Считываем и выводи на экран значения стандартных атрибутов потока:
   {  // Значение статуса освобождения ресурсов потока
      int state_detach = -1; 
      // Значение параметра планирования
      struct sched_param state_sched; 
      // Значение стратегии планирования
      int state_policy = -1; 
      // Значения признаков наследования планирования
      int state_inheritsched = -1; 
      // Переменная для сохранения размера стека
      int state_steck_s = 0;
      // Переменная для сохранения данных об области конкуренции
      int state_scope = -1; 
      // Переменная в которую будет записан размер буфера защиты
      // стека от переполнения
      int state_guard = -1; 
                              
      //1. Статус освобождения ресурсов (описателя) потока управления 
      // после его завершения
      printf ("  Определение статуса освобождения ресурсов: ");
      //Считываем статус и проверяем наличие ошибки при считывании
      if (0==pthread_attr_getdetachstate (&attr,&state_detach))
      {  //Анализируем считаный статуса и выводим результат в консоль
         switch (state_detach)
         {  case PTHREAD_CREATE_DETACHED: printf ("DETACHED\n"); break;
            case PTHREAD_CREATE_JOINABLE: printf ("JOINABLE\n"); break;
            default: printf ("неизвестный статус (%d)\n",state_detach); 
                     break;
         }
      }
      else printf ("ошибка\n");

      // 2. Приоритет потока управления
      printf ("  Определение приоритета потока управления: ");
      //Считываем приоритет потока управления
      if (0==pthread_attr_getschedparam (&attr,&state_sched))
      {  // Выводим на консоль приоритет потока по умолчанию
         printf (" %d\n",state_sched.sched_priority);
      }
      else printf ("ошибка\n");

      // 3. Стратегия планирования потока управления
      printf ("  Определение стратегии планирования:        ");
      // Считываем стратегию и проверяем наличие ошибки при считывании
      if (0==pthread_attr_getschedpolicy (&attr,&state_policy))
      {  // Анализируем считаный статуса и выводим результат в консоль
         switch (state_policy)
         {  case SCHED_FIFO: printf ("FIFO\n"); break;
            case SCHED_RR: printf ("RR\n"); break;
            case SCHED_OTHER: printf ("OTHER\n"); break;
            default: printf ("неизвестная стратегия (%d)\n"
                              ,state_policy); 
                     break;
         }
      }
      else printf ("ошибка\n");

      // 4. Атребуты наследования планирования потока управления
      printf ("  Определение атрибутов наследования:        ");
      // Считываем атрибуты наследования и проверяем наличие ошибки 
      // при считывании
      if (0==pthread_attr_getinheritsched (&attr,&state_inheritsched))
      {  //Анализируем считаный атрибут и выводим результат в консоль
         switch (state_inheritsched)
         {   case PTHREAD_INHERIT_SCHED: printf ("INHERIT\n"); break;
             case PTHREAD_EXPLICIT_SCHED: printf ("EXPLICIT\n"); break;
             default: printf ("неизвестный атрибут (%d)\n" 
                               ,state_inheritsched); 
                      break;
         }
      }
      else printf ("ошибка\n");

      // 5. Размер стека для потока
      printf ("  Определение размера стека:                 ");
      // Считываем размер стека
      if (0==pthread_attr_getstacksize (&attr,&state_steck_s))
      {  // Выводим результат в консоль
         printf ("%d Кбайт\n",state_steck_s/1024);      
      }
      else printf ("ошибка\n");

      // 6. Область конкуренции потока
      printf ("  Определение области конкуренции:           ");
      // Считываем значение атрибута
      if (0==pthread_attr_getscope (&attr,&state_scope))
      {  // Анализируем считаный атрибут и выводим результат в консоль
         switch (state_scope)
         {  case PTHREAD_SCOPE_SYSTEM: printf ("SYSTEM\n"); break;
            case PTHREAD_SCOPE_PROCESS: printf ("PROCESS\n"); break;
            default: printf ("неизвестный атрибут (%d)\n",state_scope); 
                     break;
         }
      }
      else printf ("ошибка\n");
      
      // 7. Защита стека от переполнения
      printf ("  Защита стека от переполнения:              ");
      // Считываем значение атрибута
      if (0==pthread_attr_getguardsize (&attr,&state_guard))
      {  // Анализируем считаный атрибут и выводим результат в консоль
         if (state_guard>0)
            printf ("буфер защиты %d байт\n",state_guard);
         else
            printf ("нет защиты\n");
      }
      else printf ("ошибка\n");
   }
  
   //Установка атрибутов потока управления для создания потока.
   //Создаваемый поток будет:
   // - автоматически освобождать ресурсы (описатель) потока.
   // - иметь стратегию планирования FIFO
   // - приоритет 50
   // - стратегия планирования будет определятся атрибутами потока
   // - размер стека 16 мб
   // - буфер защиты стека от переполнения - 8 кб
   // - область конкурирования – все потоки процесса
   printf ("Установка атрибутов потока управления:\n");
   {  struct sched_param new_sched;  // Значение параметра планирования
      new_sched.sched_priority = 50;
    
      // Устанавливаем статус освобождения ресурсов потока: 
      // автоматически при завершении работы потока
      printf ("  Установка статуса освобождения ресурсов: ");
      if (0==pthread_attr_setdetachstate (&attr,PTHREAD_CREATE_DETACHED))
         printf ("OK\n");  
      else printf ("ошибка\n");

      // Установка стратегии планирования: FIFO
      printf ("  Установка стратегии планирования:        ");
      if (0==pthread_attr_setschedpolicy (&attr,SCHED_FIFO))
         printf ("OK\n");
      else printf ("ошибка\n");

      // Установка приоритет потока: 50.
      printf ("  Установка приоритета:                    ");
      if (0==pthread_attr_setschedparam (&attr,&new_sched))
         printf ("OK\n");
      else printf ("ошибка\n");

      // Установка атрибута наследования: параметры планирования брать 
      // из структуры атрибутов потока (attr)
      printf ("  Установка атрибута наследования:         ");
      if (0==pthread_attr_setinheritsched (&attr,PTHREAD_EXPLICIT_SCHED))
         printf ("OK\n");
      else printf ("ошибка\n");

      // Установка размера стека: 16 Мб.
      printf ("  Установка размера стека:                 ");
      if (0==pthread_attr_setstacksize (&attr, 16777216))
         printf ("OK\n");
      else printf ("ошибка\n");

      // Установка защиты стека от переполнения: буфер защиты 8 кб
      printf ("  Установка защиты стека от переполнения:  ");
      if (0==pthread_attr_setguardsize (&attr, 8192))
         printf ("OK\n");
      else printf ("ошибка\n");

      // Установка области конкуренции: со всеми потоками процесса.
      printf ("  Установка области конкуренции:           ");
      if (0==pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM))
         printf ("OK\n");
      else printf ("ошибка\n");
   }

   // Запуск потока управления с устаноавленными выше атрибутами. 
   // В рамках потока будет выполняться функция void pthread_func (void).
   printf ("Запуск потока управления: ");
   if ( 0 == pthread_create (&new_pthread, &attr,(void*(*)(void*)) 
             pthread_func,NULL))
    	{  }
   else printf ("ошибка\n");
 
   //Задержка на 10 секунд
   sleep (10);

   printf ("Работа программы завершена\n");
    
   return 0;
}



//Функция, выполняемая в рамках созданного потока
void pthread_func (void)
{
   int i=0;
   // Уведомление о запуске потока
   printf ("поток запущен\n");

   // Индикация работы потока: вывод раз в секунду счетчика
   // циклов в течении 5 секунд
   printf ("Поток работает:\n");
   for (i=0;i<5; i++)
   {
      printf ("   %d\n",i);
      sleep (1);
   }
   printf ("Поток завершен\n");

   //Завершение работы потока
   return;
}

Результат (вывод в консоль):


Установка стандартных атрибутов потока управления: ОК
Определение атрибутов потока управления:
   Определение статуса освобождения ресурсов: JOINABLE
   Определение приоритета потока управления:  0
   Определение стратегии планирования:        OTHER
   Определение атрибутов наследования:        INHERIT
   Определение размера стека:                 8192 Кбайт
   Определение области конкуренции:           SYSTEM
   Защита стека от переполнения:              буфер защиты 4096 байт
Установка атрибутов потока управления:
   Установка статуса освобождения ресурсов: OK
   Установка стратегии планирования:        OK
   Установка приоритета:                    OK
   Установка атрибута наследования:         OK
   Установка размера стека:                 OK
   Установка защиты стека от переполнения:  OK
   Установка области конкуренции:           OK
Запуск потока управления: поток запущен
Поток работает:
   0
   1
   2
   3
   4
Поток завершен
Работа программы завершена


Пример 2:

В примере создается поток управления с атрибутами «по умолчанию», в рамках которого работает функция pthread_func, которая в течении 5-ти секунд, с темпом раз в секунду, вводит сообщения о работе потока (счетчик циклов). Затем поток завершается и завершается работа программы.


#include < stdio.h >   // Для printf
#include < pthread.h > // Для pthread_create

// Функция, запускаемая в рамках потока управления
void pthread_func (void);

int main (void)
{
   // Переменная в которую будет записан описатель атрибутов потока
   pthread_t new_pthread;

   // Запуск потока управления с атрибутами по умолчанию. 
   // В рамках потока будет выполняться функция void pthread_func (void).
   printf ("Запуск потока управления: ");
   if ( 0 == pthread_create (&new_pthread, &attr,(void*(*)(void*)) 
             pthread_func,NULL))
   {  }
   else printf ("ошибка\n");
 
   //Задержка на 10 секунд
   sleep (10);

   printf ("Работа программы завершена\n");
    
   return 0;
}


//Функция, выполняемая в рамках созданного потока
void pthread_func (void)
{
   int i=0;
   // Уведомление о запуске потока
   printf ("поток запущен\n");

   // Индикация работы потока: вывод раз в секунду счетчика
   // циклов в течении 5 секунд
   printf ("Поток работает:\n");
   for (i=0;i<5; i++)
   {
      printf ("   %d\n",i);
      sleep (1);
   }
   printf ("Поток завершен\n");

   //Завершение работы потока
   return;
}

Результат (вывод в консоль):


Запуск потока управления: поток запущен
Поток работает:
   0
   1
   2
   3
   4
Поток завершен
Работа программы завершена


Смотри так же:

pthread_attr_getdetachstate
pthread_attr_getinheritsched
pthread_attr_getschedparam
pthread_attr_getschedpolicy
pthread_attr_init


Яндекс.Метрика

Рейтинг@Mail.ru