class SF::Thread

• SF::Thread
• Reference
• Object

Overview

Utility class to manipulate threads

Threads provide a way to run multiple parts of the code in parallel. When you launch a new thread, the execution is split and both the new thread and the caller run in parallel.

To use a SF::Thread, you construct it directly with the function to execute as the entry point of the thread. SF::Thread has multiple template constructors, which means that you can use several types of entry points:

• non-member functions with no argument
• non-member functions with one argument of any type
• functors with no argument (this one is particularly useful for compatibility with boost/std::%bind)
• functors with one argument of any type
• member functions from any class with no argument

The function argument, if any, is copied in the SF::Thread instance, as well as the functor (if the corresponding constructor is used). Class instances, however, are passed by pointer so you must make sure that the object won't be destroyed while the thread is still using it.

The thread ends when its function is terminated. If the owner SF::Thread instance is destroyed before the thread is finished, the destructor will wait (see #wait())

Usage examples:

# example 1: non member function with one argument

void threadFunc(int argument)
    // [...]
end

thread = SF::Thread.new(&threadFunc, 5)
thread.launch() # start the thread (internally calls threadFunc(5))

# example 2: member function

class Task
public:
    void run()
        // [...]
    end
end

Task task
thread = SF::Thread.new(&Task.run, &task)
thread.launch() # start the thread (internally calls task.run())

# example 3: functor

struct Task
    void operator()()
        // [...]
    end
end

thread = SF::Thread.new(Task())
thread.launch() # start the thread (internally calls operator() on the Task instance)

Creating parallel threads of execution can be dangerous: all threads inside the same process share the same memory space, which means that you may end up accessing the same variable from multiple threads at the same time. To prevent this kind of situations, you can use mutexes (see SF::Mutex).

See also: SF::Mutex

Included Modules

• SF::NonCopyable

Defined in:

Constructors

• .new(function : -> )

  Construct the thread from a functor with an argument

Instance Method Summary

• #finalize

  Destructor

• #launch

  Run the thread

• #terminate

  Terminate the thread

• #wait

  Wait until the thread finishes

Constructor Detail

void function(int arg)

# --- or ----

struct Functor
    void operator()(std::string arg)
end

Instance Method Detail