Многопоточное программирование презентация

пространстве одного процесса.

Различные процессы выполняются в разных адресных пространствах.
Треды имеют «собственный» стек и набор регистров. Глобальные данные являются общими.
Как локальные, так и глобальные переменные процессов являются «собственными».

многопоточного программирования встроены в язык Java.
Переносимая библиотека pthreads, разработанная Xavier Leroy, предоставляет средства для создания и управления тредами.

*inAttribute,
void *(*inFunction)(void *),
void *inArg
);

void pthread_exit(void *inReturnValue)

int pthread_join(
pthread_t inHandle,
void **outReturnValue,
);

pthread_create

pthread_join

pthread_exit

родительский тред

тред-потомок

*), void *inArg);

outHandle – используется для возвращение в тред-родитель идентификатора треда потомка;
inAttribute – атрибуты треда;
inFunction – указатель на функцию, содержащую код, выполняемый тредом;
inArg – указатель на аргумент, передаваемый в тред;

получает указатель в качестве возвращаемых данных.
Обычное завершение функции и возврат указателя на void*, выполняемой тредом эквивалентно вызову функции pthread_exit, которая используется в случае, когда надо завершить тред из функций, вызванных этой функцией.

функции приводит к блокировке родительского треда до момента завершения треда-потомка, соответствующего индентификатору inHandle. В область, указанную параметром outReturnValue, записывается указатель, возвращенный завершившимся тредом.

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

*r;
int numt, n;

double f(double x)
{
return 4 / (1 + x * x);
}

= *(int*)addr;

s = 0.0;
for(p = a + my * h; p < b; p += numt * h)
{
s += h*(f(p) + f(p + h))/2.;
}
r[my] = s;
return (void*)(r + my);
}

= atoi(argv[1]);
n = atoi(argv[2]);
threads = malloc(numt * sizeof(pthread_t));
r = malloc(numt * sizeof(double));
h = (b - a) / n;

for(i = 0; i < numt; i ++)
pthread_create(threads + i, NULL, worker, (void*)&i);

S = 0;
for(i = 0; i < numt; i ++) {
double* r;

pthread_join(threads[i], (void**)&r);
S += *r;
}
printf("pi = %lf\n", S);
}

она может демонстрировать различное наблюдаемое поведение

= 1

= 2

может «наблюдаться» другими тредами

Неделимая операция

работы с которыми предусмотрены две неделимые операции:
увеличить значение семафора на 1;
дождаться пока значение семафора не станет положительным и уменьшить значение семафора на 1.

int value)
semaphor – семафор,
flag – флаг (0 – внутри процесса, 1 – между процессами)
value – начальное значение
sem_post(sem_t* semaphor) – увеличение семафора sem_wait(sem_t* semaphor) – уменьшение семафора

rear;
static int front;
static sem_t empty;
static sem_t full;


void
init ()
{
front = 0;
rear = 0;
sem_init (&empty, 0, N);
sem_init (&full, 0, 0);
}

while (i != -1)
{
sem_wait (&full);
i = buf[rear];
process(i);
printf ("consumed: %d\n", i);
rear = (rear + 1) % N;
sem_post (&empty);
}
}

!= -1)
{
sem_wait (&empty);
printf ("Enter number:");
scanf ("%d", &i);
buf[front] = i;
front = (front + 1) % N;
sem_post (&full);
}
}

pthread_create (&pt, NULL, producer, NULL);
pthread_create (&ct, NULL, consumer, NULL);
pthread_join (ct, NULL);
pthread_join (pt, NULL);
}

только одним тредом.

a = a + 1

Как сделать операцию a = a + 1 неделимой?

+ 1;
in1 = false;
}

2-й тред:
while(true) {
while(in1);
in2= true
a = a + 1;
in2 = false;
}

исключение);
Объявление и инициализация:
pthread_mutex_t – тип для взаимного исключения;
pthread_mutex_init(pthread_mutex_t* mutex, void* attribute);
pthread_mutex_destroy(pthread_mutex_t* mutex);
Захват и освобождение мютекса:
pthread_mutex_lock(pthread_mutex_t* mutex);
pthread_mutex_unlock(pthread_mutex_t* lock);
Освобождение мютекса может быть осуществлено только тем тредом, который производил его захват.

матрицы

double *A, *B, *C;

* sizeof (double));
B = malloc (N * N * sizeof (double));
C = malloc (N * N * sizeof (double));

for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
{
A[i * N + j] = 1;
B[i * N + j] = 2;
}
}

void
print_result ()
{
… }

{
int oldrow;

pthread_mutex_lock (&mut);
oldrow = nrow;
nrow++;
pthread_mutex_unlock (&mut);

int j;
double t = 0.0;

for (j = 0; j < N; j++)
t += A[oldrow * N + j] * B[j * N + i];

C[oldrow * N + i] = t;
}
}
return NULL;
}

NULL);
nthreads = atoi (argv[1]);
threads = malloc (nthreads * sizeof (pthread_t));

N = atoi (argv[2]);
setup_matrices ();

(threads + i, NULL, worker, NULL);

for (i = 0; i < nthreads; i++)
pthread_join (threads[i], NULL);

if (argc > 3)
print_result ();

pthread_mutex_destory(&mut);

}