Re: Free lightweight C++ signals and slots library
On 15/08/2012 21:20, Marcel M?ller wrote:
On 13.08.2012 16:26, Leigh Johnston wrote:
An event handler can fire other events no problem if the programmer
knows that it is the same thread (which is almost certainly the case if
the programmer is in control of the software design).
If an event handler can safely fire other events (with the restriction),
it must always be called from the same thread. And furthermore the event
that it fires must also always be called by the same thread only. In
fact that means that your application must be single threaded with
respect to event processing.
No it can be multi-threaded; thread 1 triggers events and handles events
for signal 1 and thread 2 triggers events and handles events for signal
2; no deadlock; no problems.
The following code deadlocks:
#include <neolib/neolib.hpp>
#include <iostream>
#include <neolib/thread.hpp>
#include <neolib/signal.hpp>
#include <neolib/slot.hpp>
neolib::signal<void()> on_event_1;
neolib::signal<void()> on_event_2;
class thread_one : public neolib::thread, public neolib::has_slots<>
{
public:
thread_one() : iDone(false)
{
on_event_1(*this, &thread_one::handler);
}
private:
virtual void task()
{
on_event_1.trigger();
}
void handler()
{
std::cout << "thread_one::handler()" << std::endl;
if (!iDone)
{
sleep(1000);
iDone = true;
on_event_2.trigger();
}
}
private:
bool iDone;
};
class thread_two : public neolib::thread, public neolib::has_slots<>
{
public:
thread_two() : iDone(false)
{
on_event_2(*this, &thread_two::handler);
}
private:
virtual void task()
{
on_event_2.trigger();
}
void handler()
{
std::cout << "thread_two::handler()" << std::endl;
if (!iDone)
{
sleep(500);
iDone = true;
on_event_1.trigger();
}
}
private:
bool iDone;
};
void deadlock()
{
thread_one t1;
thread_two t2;
t1.start();
t2.start();
t1.wait();
t2.wait();
}
The following code does not (and is quite safe):
#include <neolib/neolib.hpp>
#include <iostream>
#include <neolib/thread.hpp>
#include <neolib/signal.hpp>
#include <neolib/slot.hpp>
neolib::signal<void()> on_event_1;
neolib::signal<void()> on_event_2;
class thread_one : public neolib::thread, public neolib::has_slots<>
{
public:
thread_one() : iDone(false)
{
on_event_1(*this, &thread_one::handler);
}
private:
virtual void task()
{
on_event_1.trigger();
}
void handler()
{
std::cout << "thread_one::handler()" << std::endl;
if (!iDone)
{
sleep(1000);
iDone = true;
on_event_1.trigger();
}
}
private:
bool iDone;
};
class thread_two : public neolib::thread, public neolib::has_slots<>
{
public:
thread_two() : iDone(false)
{
on_event_2(*this, &thread_two::handler);
}
private:
virtual void task()
{
on_event_2.trigger();
}
void handler()
{
std::cout << "thread_two::handler()" << std::endl;
if (!iDone)
{
sleep(500);
iDone = true;
on_event_2.trigger();
}
}
private:
bool iDone;
};
void deadlock()
{
thread_one t1;
thread_two t2;
t1.start();
t2.start();
t1.wait();
t2.wait();
}