include h>

José González
P1
No responde
0/25
P2
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
static void
sig_mg(int);
//administrador de señales "manager"
int main(void)
{
if (signal(SIGINT, sig_mg) == SIG_ERR)
printf("can't catch controlc");
signal (SIGUSR1, SIG_IGN); //ignoramos señales de usuarios
signal (SIGUSR2, SIG_IGN);
signal (8, SIG_IGN);
signal (13, SIG_IGN);
//ignoramos otas señales
signal (14, SIG_IGN);
for ( ; ; )
pause();
}
static void sig_mg(int signo)
/* argument is signal number */
{
if (signo == SIGINT){
sleep(2);
//esperamos dos segundos.
printf("received control c\n");
exit(0);}
else return;
}
/* No usar constantes en lugar de nombres de señales */
24/25
P3
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define linea 100
void main(){
int exit=1;
char l[linea];
FILE * sd, *sd2;
pid_t pid;
int pfdm[2];
int pfdn[2];
while(exit){ // Su programa no termina con quit y crea todo nuevamente por cada expresión (muchos hijos)
printf("Ingrese operacion a realizar:");
fflush;
// A este fflush le fata fflush(stdout)
scanf("%s",l);
printf(" %s:",l);
if (pipe(pfdm) < 0) {
//Creamos una pipa.
perror("pipe");
//exit(1);
}
if (pipe(pfdn) < 0) {
perror("pipe");
//exit(1);
}
if ((pid = fork()) < 0) {
perror("fork");
//exit(1);
}
if (pid == 0) {
int junk;
dup2(pfdm[0], 0);
to read from the pipe.
dup2(pfdn[1], 1);
close(pfdm[1]);
//Creamos una pipa.
//creamos un proceso hijo.
// Attach standard input of this child process
execlp("bc", "bc", NULL);
perror("exec");
// exit(-1);
}
//proceso padre:
close(pfdm[0]);
close(pfdn[1]);
sd = fdopen(pfdm[1], "w");
sd2 = fdopen(pfdn[0], "r");
fprintf(sd, "%s\n",l);
sd2 = fdopen(pfdn[0], "r");
fscanf(sd2,"%s",l);
//fscanf(sd2,"%s",l);
printf( "%s\n",l);
}
}
18/25
P4
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define INCREMENTOS 2000000
int contador;
pthread_mutex_t candado = PTHREAD_MUTEX_INITIALIZER;
int valorfinal,valorfinal2;
void * incremento_unlock(void * arg) // No calcula valor máximo
{
int i;
for (i = 0; i <INCREMENTOS; i++)
contador++;
valorfinal2=contador;
return(NULL);
}
void * incremento_lock(void * arg) // No calcula valor máximo
{
int i;
for (i = 0; i <INCREMENTOS; i++){
pthread_mutex_lock(&candado);
contador++;
if(i==INCREMENTOS-1)valorfinal2=contador;
pthread_mutex_unlock(&candado);}
//printf("El valor maximo alcansado incrementando con control:%d \ n",contador);
return(NULL);
}
int main(int argc, char *argv[])
{
int error, i;
contador = 0;
pthread_t tid;
if(argv[1]){ // argv[1] es un string, nunca será falso
error = pthread_create(&tid, NULL, incremento_lock, NULL);
if (error != 0){
printf("no se puede crear el hilo\n");
exit(0);}
for (i = 0; i <INCREMENTOS; i++){ // No calcula valor mínimo
pthread_mutex_lock(&candado);
contador-- ;
if(i==INCREMENTOS-1)valorfinal=contador;
pthread_mutex_unlock(&candado);}
}
else {
error = pthread_create(&tid, NULL, incremento_unlock, NULL);
if (error != 0){
printf("no se puede crear el hilo \n");
exit(0);}
for (i = 0; i <INCREMENTOS; i++)
contador-- ;
valorfinal=contador;
}
pthread_join(tid, NULL);
printf("El valor final de contador es %i\n", contador);
printf("El valor final de hilo incremental es %i\n", valorfinal2); //imprimo los 3 valores por que podria darse el caso que no
termine el hilo principal primero y no podriamos saber el valor de termino.
printf("El valor final de hilo decremental es %i\n", valorfinal);
}
/* Usted se equivoca en el cálculo de los valores extremos, no son los finales necesariamente.*/
21/25