ich würde gerne Aufgaben effizient in Threads aufteilen.
Vorrausgesetzt ich habe erkannt, dass ich 4 Threads
parallel laufen lassen kann, dann würde ich
ein Array mit 4 Threads erzeugen.

Kann ich die Abzuarbeitende Funktion eine Threadinstanz ändern, oder muss ich
Jedes mal einen ganzen neune Thread erzeugen, wenn eine Funktion abgearbeitet worden ist.

Gruß

Kann ich in einer Threadfunktion herrausfinden, welche ID der Thread momentan hat ??

Einfach zum Prüfen, ob auf brav alle ihre Arbeit machen.

EDIt: Also ich arbeite mit boost::Tread

also wenn cih auf den aktuellen Thread zugriff habe, dann ist es kein Problem.
Aber ich suche nach etwas, wo ich innerhalb des Threads die eigene ID rausfindenkann...
Ich hatte es davor schonmal mit
boost::this_thread::id
versucht..

EDIT: Trotzdem cooler link =).

Außerdem ging mir es eigentlich zu schnell wie du dann eine Lösung gefunden hast.

Kannst du mal deinen Code posten?

Ich glaube volkard meinte es etwa so:

#include <iostream>
#include <boost/thread.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>

class Task;

class TaskQueue{
public:
	void add(Task* task){
		boost::mutex::scoped_lock l(mutex);
		queue.push_back(task);
		empty_condition.notify_one();
		std::cout << "adding task" << std::endl;
	}

	Task* task(){
		boost::mutex::scoped_lock lock(mutex);
		while(queue.empty())
			empty_condition.wait(lock);
		typename std::list<Task*>::iterator it = queue.begin();
		queue.erase(it);
		std::cout << "removing task" << std::endl;
		return *it;
	}

private:
	boost::mutex mutex;
	std::list<Task*> queue;
	boost::condition_variable empty_condition;
};

class Task{
public:
	virtual void execute() = 0;
};

class Thread{
public:
	Thread(TaskQueue& task_source) : task_source(task_source){}

	void operator()(){
		while(true){
			Task* task = task_source.task();
			task->execute();
			delete task;
		}
	}

private:
	TaskQueue& task_source;
};

class ThreadPool : public TaskQueue{
public:
	ThreadPool(unsigned int count){
		for(int i=0; i<count; ++i){
			boost::thread(Thread(*this));
		}
	}

};

class CounterTask : public Task{
public:
	CounterTask(unsigned int i) : i(i){}

	virtual void execute(){
		for(int j=0; j<i; ++j){
			std::cout << j << std::endl;
		}
	}

private:
	unsigned int i;
};

int main(){
	ThreadPool pool(5);
	for(int i=0; i<11; ++i){
		pool.add(new CounterTask(i*1000));
	}
	while(true);
}

ich habs mir aus dem alten zusammengebaut. Find deine Lösung aber schöner =).

Werd ich mir merken =).

Aber im Grunde machen wir beide das Selbe.

nicht sonderlich viel. War eher als belanglose Frage zu später Stunde gedacht.
Aber ja ich meine Meshes.

Davor erwarte ich mir erstmal ne ordentliche Mathe-Library mit schönen fixed-size Vektor und Matrixklassen, hübsch optimiert mit SSE und allem. Das wäre IMO ausreichend allgemein um wirklich nützlich zu sein. Jede 2D/3D Engine implementiert sich das selbst, jedes GUI Toolkit etc. - das muss ja nicht sein.

Darauf könnte man dann evtl. was aufbauen was mit Meshes arbeitet.

Aber nochmal ein weiter Sprung. Kennst Du eine gute Beschreibung wo das Thema Dynamisch gelinkte Bibliotheken gut angeht.
In erster Linie wie man die Schnittstelle ordentlich definiert. Also auch die Rückgabewerte. Ich brächt sogar ne Callback.... Kenne mich aber mit DLLs nicht aus. Plattform unabhängig sollte der Code auch noch sein. ...
Dann sollte das ganze Ding auch noch Threadsafe sein.
Ich frage, weil das Thema neu für mich ist, und der erste Eindruck eienr Sache
meißt am besten hängen bleibt und ich möchte nicht mit einer schlechten Beschreibung beginnen...

Grüße

EDIT: Will damit sagen, ich kann mir selbst was raussuchen, aber ich kann nicht entscheiden ob das dann gut ist.