2 Threads im Gleichschritt laufen lassen

Hallo allerseits,

folgendes Problem quält mich zurzeit:
Ich habe 2 Threads, die beide je 3, jeweils gleichwertige (aber nicht identische) Funktionen aufrufen (und das in einer Endlosschleife).
Nun soll jedes "Funktionenpaar" quasigleichzeitig laufen. Dabei ist es egal, welcher mit seiner Funktion zuerst beginnt/fertig ist. Wichtig ist nur: Der nächste Schritt darf erst gemacht werden, wenn beide mit dem vorherigen Schritt fertig sind.
Habe schon mit Mutex und Semaphoren hantiert, aber die Lösung will mir nicht gelingen.

Danke für jegliche Hilfe,
Julian

P.S.: Die Plattform ist Windows (ab XP), Windows- und MFC-Boardmittel sind daher erlaubt.

hustbaer

http://www.boost.org/doc/libs/1_45_0/doc/html/thread/synchronization.html#thread.synchronization.barriers

Tachyon

Stichwort Barriere. Bei einer Barriere kannst Du n Funktionen anmelden. Am Barrierepunkt wird dann so lange gewartet, bis alle n angemeldeten Funktionen signalisiert haben, dass sie fertig sind. Erst dann geht es weiter.
Mit dem Suchbegriff solltest Du weiter kommen. In der boost-Sammlung gibt es dafür übrigens bereits eine fertige Lösung.

Moin nochmal,

danke für eure schnellen Antworten.
Das waren genau die Stichworte, die mich in Google und hier im Forum nun ein gutes Stück weiter gebracht haben.
Was die Boost Library angeht: Ich tue mich schwer damit, eine Library einzubauen nur wegen einer einzelnen Funktionalität. Aber das wurde ja anscheinend hier schon mal thematisiert (wen es spontan interessiert: http://www.c-plusplus.net/forum/249950).

Ich werde mich jetzt erstmal da dran hängen, und wenn es dann konkrete Probleme gibt, nochmal anklopfen...

Besten Dank,
Julian

Ich nochmal
Ich habe nun mal selbst eine einfache Barrier-Klasse gebaut, da ich nicht wegen einer Klasse die ganze Boost-Library verwenden wollte.
Vieleicht mag sich den mal jemand angucken um auf mögliche Race-Conditions oder grobe Performanceprobleme hinzuweisen (meine eigenen Tests waren bis jetzt erfolgreich).
Ansonsten gebe ich den Code einfach mal preis für alle, die auch danach suchen:

// Barrier.h
#pragma once

#include <Windows.h>

class CBarrier
{
public:
	CBarrier(int nCount);
	~CBarrier(void);

	void Wait();

private:
	int m_nCount;
	int m_nWaiting;
	int m_nProceeding;
	CRITICAL_SECTION m_zCritical;
	HANDLE m_hEventAllWaiting;
	HANDLE m_hEventAllProceeding;
};

// Barrier.cpp
#include "Barrier.h"

CBarrier::CBarrier(int nCount)
{
	InitializeCriticalSection(&m_zCritical);
	m_hEventAllWaiting = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hEventAllProceeding = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_nCount = nCount;
	m_nWaiting = 0;
	m_nProceeding = 0;
}

CBarrier::~CBarrier()
{
	DeleteCriticalSection(&m_zCritical);
	CloseHandle(m_hEventAllWaiting);
	CloseHandle(m_hEventAllProceeding);
}

void CBarrier::Wait(void)
{
	// Wait for all threads to reach the barrier
	EnterCriticalSection(&m_zCritical);
	m_nWaiting++;
	if (m_nWaiting >= m_nCount)
	{
		// The last thread reached the barrier
		m_nProceeding = 0;
		ResetEvent(m_hEventAllProceeding);
		SetEvent(m_hEventAllWaiting);
	}
	LeaveCriticalSection(&m_zCritical);	
	(void)WaitForSingleObject(m_hEventAllWaiting, INFINITE);

	// Wait for all threads to pass the barrier
	EnterCriticalSection(&m_zCritical);
	m_nProceeding++;
	if (m_nProceeding >= m_nCount)
	{
		// The last thread passed the barrier
		m_nWaiting = 0;
		ResetEvent(m_hEventAllWaiting);
		SetEvent(m_hEventAllProceeding);
	}
	LeaveCriticalSection(&m_zCritical);	
	(void)WaitForSingleObject(m_hEventAllProceeding, INFINITE);
}

314159265358979

Nicht plattformunabhängig, bäh.

Immer wieder erstaunlich, wie fix das hier mit den Antworten geht

314159265358979 schrieb:

Nicht plattformunabhängig, bäh.

Ja, stimmt. Aber zugegeben: Das war auch nicht Ziel meiner Implementierung.