(3),多线程的简单示例
一个简单的Linux多线程示例如下:
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void * thread_function ( * arg void);
mensagem char [] = "Olá Mundo";
int main ()
{
res int;
pthread_t a_thread;
thread_result * vazia;
res = pthread_create (& a_thread, NULL, thread_function, (void *) mensagem);
if (res = 0!)
{
perror ( "criação da linha falhou!");
saída (EXIT_FAILURE);
}
Printf ( "Esperando por fio ao fim ... / n");
res = pthread_join (a_thread, & thread_result);
if (res! = 0)
{
perror ("
saída (EXIT_FAILURE);
}
Printf ( "thread juntou-se, voltou% s / n", (char *) thread_result);
printf ( "mensagem é agora% s / n", da mensagem);
saída (EXIT_FAILURE);
}
Void * thread_function (void * arg)
{
printf ( "thread_function está a executar o argumento era% s / n.", (Char *) arg);
sono (3);
strcpy (mensagem, "Bye!");
pthread_exit ( "Obrigado por seu tempo de CPU!");
}
编译语句如下:
gcc -lpthread thread1.c -o thread1
输出结果是:
. $ / Thread1 [输出]:
thread_function está em execução. Argumento era Olá mundo
espera para a linha de chegada ...
Tópico juntou, ele retornou Obrigado pelo seu tempo de CPU!
Mensagem é agora Bye!
Neste exemplo, pthread_exit (* retval nulo) próprio refere-se a um objecto que é retornado por meio de
uma agulha, e, por conseguinte, pthread_join (pthread_t th, nula ** thread_return); thread_return em
um ponteiro dois para o valor de retorno ponteiro rosca . Podemos ver, criamos um novo segmento para modificar uma série de
mensagens valores, enquanto que o segmento original também pode acessar a matriz. Se chamarmos um garfo em vez de
pthread_create, não haveria tais efeitos. Porque depois de um garfo para criar um processo filho, o processo de criança irá copiar
o processo pai, os dois separados, interferem um com o outro, mas entre as roscas estão relacionadas com o processo de compartilhamento de recursos.
<4>, exemplos de vários segmentos
(1), criar uma nova 1.Multithreading.c arquivo:
/*1.Multithreading.c: c múltipla Programação do thread no Linux * /
#include "pthread.h"
#include <stdio.h>
#include <sys / time.h>
#include <string.h>
#include <time.h>
#define MAX 10
Tópico pthread_t [2];
pthread_mutex_t MUT;
int Number = 0, I;
void * Thread1 ()
{
printf ( "thread1: Eu sou rosca 1 \ n");
sistema ( "ls-l");
pthread_exit (NULL);
}
Void * thread2 ()
{
int j;
printf ( "thread1: Eu sou rosca 2 \ n");
para (j = 0; j <5; j ++)
{
sono (1);
printf ( "% GS \ n", j + 1);
}
Pthread_exit (NULL);
}
Vazio thread_create (void)
{
int temp;
memset (& fio, 0, sizeof (thread)); // comentário1
/ *创建线程* /
if ((temp = pthread_create (& fio [0], NULL, thread1, NULL)) = 0!)
// comment2
printf ( "线程1创建失败\ n");
else
printf ( "线程1被创建\ n");
if ((temp = pthread_create (& segmento [1],
comment3 //
o printf ( "2 criação da linha falhou \ n-");
a outra
o printf ( "thread 2 é criado \ n-");
}
vazio thread_wait (void)
{
/ * espera para o fim da rosca * /
IF (Tópico [0] =! 0)
{// comment4
pthread_join (segmento [0], NULL);
printf ( "thread 1 tenha terminado \ n-");
}
IF (segmento [1] == 0)
{
// pthread_join (segmento [1], NULL );
o printf ( "thread 2 acabou \ n");
}
}
int main ()
{
/ * atributos uso padrão inicializar o mutex * /
o pthread_mutex_init (& MUT, NULL);
o printf ( "I é a função principal \ n") ;
thread_create ();
printf ( "Eu sou a função principal, o segmento está esperando para completar a tarefa \ o n-");
thread_wait ();
return 0;
}
(2), prazo de compilação:
sudo gcc 1.Multithreading.c -o 1.Multithreading -lpthread
./ 1.Multithreading
