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.

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

// 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 schrieb:

Nicht plattformunabhängig, bäh.

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