Tworzenie procesów potomnych

Witam,
jak mozna utworzyc na procesu glownego 3 watki potomne a nastepnie zapisac o nich informacje w pamieci wspolnej.
Do pamieci wspolnej maja byc zawsze zapiswane informacje o watku glownym i 3 pochodnych i takich infformacji ma byc w sumie 20, pozniej maja sie juz nie dopisywac.
np

uruchamiam program ktory tworzy 3 procesy potomne nastepnie zapisuje informacje o potomku glownym i potomnych;
PIT TTY TIME CMD

1. watek glowny
2. watek potomny
3. watek potomny
4. watek potomny

koniec programu

i kiedy znowu uruchomie program ma to samo napisac do pamieci wspolnej, tylko ze dopisujac np

1. watek glowny
2. watek potomny
3. watek potomny
4. watek potomny
5. watek glowny
6. watek potomny
7. watek potomny
8. watek potomny

itd az do 20 pozniej ma sie juz nic nie dopisywac.
program pisany jest w Linuxie w C++

Tutaj raczej chodzi o procesy a nie o wątki (dla wątków jest pthread).
Więc procesy tworzy się przez wywołanie systemowe fork() (man 2 fork).
Do działania potrzebna jest również pamięć współdzielona. Tutaj są potrzebne informacje: http://www.linuxpl.org/LPG/node64.html

wyraźnie mylisz pojęcia! Wątek i proces to nie są synonimy. Proces może mieć kilka wątków.
W większości systemów, watki w ramach jednego procesu współdzielą pamięć.
Twój opis problemu myląc pojęcia, jest niezrozumiały.

Witam,
sposob jaki wymyslilem rozwiazania tego zadania to :
utworzenie 3 procesow potomnych
utworzenie tablicy w pamieci wpolnej o rozmiarze 21
w pozycji pierwszej bedzie zapisane ile zostalo juz utworzonych procesow potomnych
nastepne procesy potomne beda zapisywane w tablicy[ilosc procesow zapisanych +1]
Teraz zastanawiam sie jak sprawdzac czy pamiec wspolna zostala utworzona i jesli zostala utworzona to zeby jej nie tworzyc na nowo
jesli nie zostala utworzona to w pozycji pierwszej wpisac 0
nastepnie przy wywolaniu procesu potomnego sprawdzac ile zostalo procesow utworzonych i przypisac nastepny PID procesu jesli ilosc procesow potomnych jest mniejsza od 20

jak na razie udało mi sie zrobić coś takiego:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include<limits.h>
#include<time.h>
#include<sys/ipc.h>

#define PROJECTID 0xFF
#define n 21

int main( void )
{
unsigned long i;
int status;

key_t key;
int id, size,flag;
unsigned i2;

unsigned *array;
printf("GENERATO pid  [%u]\n",(unsigned)getpid() );

key = ftok("/tmp",PROJECTID);
flag = IPC_CREAT | 0x1B6;
size = n*sizeof( unsigned);
id = shmget(key,size,flag);// tworzenie segmentu pamieci


//watki
for( i=0;i<3;i++ )
{
switch( fork() )
{
case -1: perror( "!.!.!...Blad fork..." ); exit( 1 ); break;
case 0:
printf("%li\n",i);
printf("Child ID\t%d\n",(int)getpid() );
printf("Parent ID\t%d\n",(int)getppid());

if( id>0 )
{
printf( "...utworzony segment wspólny [%u][0x%x]\n\t",id,key );

array = (unsigned*)shmat( id,NULL,0 ); //przylaczenie pamieci do procesu 
//Sposób dostępu do obszaru współdzielonego pamięci

printf( "\n przypisywanie1 \n" );
 *(array)=(4);
printf( "\n przypisywanie2 \n" );
printf( " cos tam %10u",*(array) );


shmdt( (void*)array );//ponownie odłączamy segment współdzielony od procesu 
printf( "\n...zakończono inicjację segmentu wspólnego\n" );
//(void)shmctl( id,IPC_RMID,&buffer ); //i usuwamy z pamięci

}
else
{
  { perror( "!.!.!..nie udalo sie utworzyc pamieci wspoldzielonej.." ); exit( 1 ); }

}
 exit( 0 ); break;
default:
  wait( &status );
  
}
}

return 0;
}
 

ale niestety nie moge wyswietlic liczby, ktora jest zapisywana do pamieci wpolnej
printf( "\n przypisywanie1 \n" );
(array)=(4);
printf( "\n przypisywanie2 \n" );
printf( " cos tam %10u",(array) );

po uruchomieniu programu wyskakuje tylko cos takiego:
GENERATO pid [28454]
0
Child ID 28455
Parent ID 28454
...utworzony segment wspólny [1015831][0xff000003]

przypisywanie1
1
Child ID 28456
Parent ID 28454
...utworzony segment wspólny [1015831][0xff000003]

przypisywanie1
2
Child ID 28457
Parent ID 28454
...utworzony segment wspólny [1015831][0xff000003]

przypisywanie1

Udało mi się coś napisać, więc umieszczam coś dla przykładu.

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>
#include<limits.h>
#include<time.h>
#include<sys/ipc.h>
#include<sys/shm.h>

#define PROJECTID 0xFF
#define n 1


int main( void )
{
unsigned long i;
unsigned long l=1;
int status;

key_t key;
int id, size,flag;
struct shmid_ds buffer;

unsigned long  i2=0;

unsigned *array;
printf("GENERATOR pid  [%u]\n",(unsigned)getpid() );

key = ftok("/tmp",PROJECTID);
flag = IPC_CREAT | 0x1B6;
size = n*sizeof( unsigned);
id = shmget(key,size,flag);// tworzenie segmentu pamieci
if( id>0 )
{
printf( "...utworzony segment wspólny [%u][0x%x]\n",id,key );
}


//watki
for( i=0;i<3;i++ )
{
switch( fork() )
{
case -1: perror( "!.!.!...Blad fork..." ); exit( 1 ); break;
case 0:
//printf("%li\n",i);
//printf("Child ID\t%d\n",(int)getpid() );
//printf("Parent ID\t%d\n",(int)getppid());

if( id>0 )
{

array = (unsigned*)shmat( id,NULL,0 ); //przylaczenie pamieci do procesu 
//Sposób dostępu do obszaru współdzielonego pamięci

i2 =  *(array+0)+1; // nastepny adres do wpisania

if(i2<41)// sprawdzanie ile zostalo juz zapisane
{
	
 *(array+i2)=(int)getppid();// rodzic
 
 i2=i2+1; 
 *(array+i2)=(int)getpid(); // potomek
 // printf( "zapisany potomek  %10u",*(array+i2) );
 *(array+0)=i2;

// printf( " \n zerowa pozycja  %10u ",*(array+0) );

}

shmdt( (void*)array );//ponownie odłączamy segment współdzielony od procesu 
}
else
{
  { perror( "!.!.!..nie udalo sie utworzyc pamieci wspoldzielonej.." ); exit( 1 ); }

}
 exit( 0 ); break;
default:
  wait( &status );
}
}

array = (unsigned*)shmat( id,NULL,0 ); //przylaczenie pamieci do procesu 
i2 =  *(array+0);

for( i=1;i<=40;i+=2 )
{
printf( "%ld. ",l );
printf( "Rodzic  %5u   ",*(array+i) );
printf( "Potomek  %5u \n",*(array+i+1) );
l++;
}
shmdt( (void*)array );//ponownie odłączamy segment współdzielony od procesu 

if(i2>=40)
{
  (void)shmctl( id,IPC_RMID,&buffer ); //i usuwamy z pamięci 
}
return 0;
}