4. [pthread] printf ?

[pthread] printf ?

  • M

    Hallo,
    brauch wieder mal eure Hilfe. Und zwar haben wir als Aufgabe einen Ringbuffer zu schreiben, den mehrerre Posix-Threads schreiben und einer lesen kann. Soweit so gut, dazu habe ich folgende Loesung:

    #include <pthread.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define THREAD_SIZE 150
#define BUFFER_SIZE 100
#define MSG_SIZE 150

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
char*			ringbuffer[BUFFER_SIZE];
int				buffer_index = -1;

void*	thread_write_function( void *ptr );
void*	thread_read_function( void *ptr );
char*	buffer_error_message( char* message, char type );

int main( int argc, char** argv ) 
{
	pthread_t threads[THREAD_SIZE];
	pthread_t thread;  /* Lesender Thread. */
	int t_return[THREAD_SIZE];
	int t_reader;
	int i;

	/* Erzeuge Threads die in den Buffer schreiben */
	for ( i = 0; i < THREAD_SIZE; i++ )
	{
		if ( t_return[i] = pthread_create( &threads[i], NULL, thread_write_function, NULL ) )
		{
			char* error_message = "Could not create Thread!";
			buffer_error_message( error_message, 'w' );
		}
	}

	/* Erzeuge Thread der liest */
	if ( t_reader = pthread_create( &thread, NULL, thread_read_function, NULL ) )
	{
		char* error_message = "Could not create Thread!";
		buffer_error_message( error_message, 'w' );	
	}

	/* Auf Threads warten */
	for ( i = 0; i < THREAD_SIZE; i++ )
	{
		pthread_join( threads[i], NULL );
	}
	pthread_join( thread, NULL );

	return 0;
}

void* thread_write_function( void *ptr )
{
	char thread_msg[MSG_SIZE];

	char* msg = "Thread message!";	
	strncat( thread_msg, msg, MSG_SIZE );
	/* ... Nachrichten zum auswerten ... */
	strncat( thread_msg, "\0", MSG_SIZE );

	buffer_error_message( thread_msg, 'w' );
}

void* thread_read_function( void *ptr )
{
	char* msg = NULL;
	while ( ( msg = buffer_error_message( NULL, 'r' ) ) != NULL )
	{
		printf( "Reader: %s\n", msg ); // <- FEHLER!?!?
	}
}

char* buffer_error_message( char* message, char type )
{
	pthread_mutex_lock( &mutex1 );	

	char* return_value = NULL;

	if ( type == 'w' ) 
	{
		buffer_index = buffer_index+1 == BUFFER_SIZE ? 0 : buffer_index+1;
		ringbuffer[buffer_index] = message;
		return_value = NULL;
	}
	else if ( type == 'r' ) 
	{
		if ( buffer_index != -1 )
		{
			return_value = ringbuffer[buffer_index];
			buffer_index = buffer_index-1 == -1 ? BUFFER_SIZE-1 : buffer_index-1;
		} 
		else
			return_value = NULL;
	}
	pthread_mutex_unlock( &mutex1 ); 

	return return_value;
}

    Funktioniert soweit auch recht gut.
    Nur kriege ich manchmal in der Zeile, wo die Ausgabe stattfindet nen Fehler.
    Auf diese Funktion greift aber nur ein Thread zu, deshalb versteh ich nicht, warum er gerade in der Zeile spinnt.

    Wo mach ich denn da den Fehler?

    mfg

    0
  • C

    und was fuer einen fehler?

    0
  • C

    Dieser Thread wurde von Moderator/in c.rackwitz aus dem Forum ANSI C in das Forum Linux/Unix verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • ?

    ich vermute mal du bekommst segmentation fault, weil du keinen speicher für msg reservierst?

    0
  • T

    moe szyslak schrieb:

    buffer_index = buffer_index-1 == -1 ? BUFFER_SIZE-1 : buffer_index-1; /* (1) */

/* ... */

return_value = NULL; /* (2) */

    das erste ist ein kandidat für the daily wtf, ansonsten stimme ich ff darin zu, dass der zurückgegebene char auf NULL zeigen könnte.
    außerdem ist buffer_index ein int. vielleicht nimmt der noch andere werte an, als -1, 0 und einen beliebigen positiven.

    0
Anmelden zum Antworten