Russian Qt Forum

Доброго времени суток господа!
Вот решил давеча повысить свои знания в Qt области, в частности в области многопоточности,
С многопоточностью я и на C# не особо дружу, так только создал поток, закинул в него указатель на функцию и был таков.

А вот в Qt беда.

Шлее пишет, что для использования потоков необходимо наследоваться от QThread, и переопределять метод run().
Отлично, а если у меня несколько функций, которые я хочу выполнять в потоке, что создавать для каждой наследника?
Пробовал в run() сделать вот так:


И связывать сигнал каждого созданного мною потока с определённой функцией класса MainWindow, однако в таком случае
происходит поочерёдное выполнение методов ( оно то и понятно в теле run() только сигнал, а сама-то функция в другом классе).

В C# вот можно так:


А вот в Qt так сделать нельзя ( пробовал создавать указатель на функцию MainWindow  и передавать).
Можно также использовать QConcurent и его почти аналог QRunnable, однако хотелось бы сделать без них.
так, а теперь собственно вопрос:
Можно ли каким-либо образом передавать указатель на функцию в run() и там выполнять (как в C#) или же
для каждого метода при использовании QThread необходимо создавать потомок со своей перегруженной функцией run() ?

На форуме есть много тем про это, да и в самой справке (http://qt-project.org/doc/qt-5.1/qtcore/qthread.html) с примерами все рассказано.

А чего ж нельзя?

C++ (Qt)
#include <QThread>
 
typedef void (*RunProc)( void );
 
class MyThread : public QThread { 
public:
	MyThread( RunProc proc ) : mProc(proc) {}
 
	void run( void )
	{
		mProc();
	}
 
	RunProc mProc;
};
 
void MyRun1( void )
{
	// do something
}
 
void MyRun2( void )
{
	// do something
}
 
int main()
{
	MyThread thread1(MyRun1);
	MyThread thread2(MyRun2);
	thread1.start();
	thread2.start();
 
	thread1.wait();
	thread2.wait();
 
    return 0;
}
 

Чего-то непонятно, ты говоришь что в Qt "так сделать нельзя" и в то же время хочешь хочешь городить костыли без QtConcurrent?
QtConcurrent::run - аналог твоего кода на С#.

К тому же наследование от QThread уже давно обявлено неоптимальным и не рекоммендуется.
Вместо этого используй QObject::moveToThread()

std::thread? http://ru.cppreference.com/w/cpp/thread/thread (http://ru.cppreference.com/w/cpp/thread/thread)

C++ (Qt)
void thead_func() { /* ... */}
 
int main() 
{
    std::thread thread(thread_func);
    thread.join();
 
    return 0;
} 
 

Igors,
спасибо огромное.

AIFox,
пусть и костыли, зато несколько "костылей" будут получше чем одна "нога",
к тому же, на мой взгляд, ножка какая-то кривоватая ( скорее всего жестоко
ошибаюсь).

m_ax,
std::  ? Так мы же вроде на Qt


А теперь, собственно,  это же вопрос более углубленно:


сие действо работает, однако если функции, сообщаемые потоку будут из
другого класса, то простым указателем на функцию не обойтись (вроде бы).

А теперь вопрос: каким образом можно связать потомок QThread с классом
(ну допустип Alfavit), у которого, например 2 или 3 метода?

Можно обойтись простым указателем на интерфейс, который декларирует необходимый метод. Или два метода. Или три метода

Ошибаетесь, QtConcurrent хорошая вещь.

std - это стандартная библиотек C++, Qt - это одна из библиотек. так почему не воспользоваться стандартной?

для этого достаточно почитать книгу про C++ или что нибудь в интернете, например: http://alenacpp.blogspot.ru/2007/04/blog-post.html

Лучше сделать интерфейс, напр

C++ (Qt)
struct CCalculator {
 virtual void DoCalc( void ) = 0;
};

Подсовываем его MyThread

C++ (Qt)
class MyThread : public QThread { 
public:
	MyThread( CCalculator * calc ) : mCalc(calc) {}
 
	void run( void )
	{
		mCalc->DoCalc();
	}
 
	CCalculator * mCalc;
};
 

Это все остается неизменным. А теперь клепаем маленькие классики (можно прямо в инклуде), напр

C++ (Qt)
struct MyCalc1 : public CCalculator {
 MyCalc1( Alfavit * a ) : mAlpha(a) {}
 void DoCalc( void )
 {
   mAlpha->DoSomething();
 }
 
 Alfavit * mAlpha;
};
 

Использование

C++ (Qt)
MyCalc1 calc1(alphavit);
MyThread thread1(&calc1);
thread1.start();
thread1.wait();

Можно и по-другому, напр

C++ (Qt)
struct Alphavit : public CCalculator {
 void DoCalc( void );
};

Так "ызячнее" но требует вмешательства в имеющиеся классы

Qt "пожирнее". Напр как узнать что std::thread завершилась? Ведь join (QThread::wait) хорош лищь для учебного примера

ну конечно..  ::)

В стандартную библиотеку потоков входит также std::future/std::promise

Ну и как мне связать это с std::thread? Открываю http://www.cplusplus.com/reference/thread/thread/ (http://www.cplusplus.com/reference/thread/thread/) (приличный справочник), никаких намеков на future/promise не вижу. А вот открыв букварь спустя минуты так 2 (максиум) увижу сигнал finished (карета подана). Ну и спрашивается - на хрена  мне грызть "гранит std" если есть куда более легкая и приятная возможность?

Детонька, Вы мне глазки не стройте  :) Первая либа которую я изучал была Turbo Professional - и это было круто (тогда, в 1990). И я помню свое стремление "объять необъятное" - ну примерно как у Вас. С той поры ничего (в принципе) не меняется. по-прежнему есть ръяно изучающие, но я уже не один из них :)

Спасибо всем огромное господа.
Действительно, надо бы мне быть повнимательнее.

Ну так m_ax все новые возможности показывает лично Страуструп, приезжает к нему домой и рассказывает/показывает. И ко мне он приезжает. И ко многим другим. Вы просто забыли подписаться у него на сайте, что бы он приезжал и вам тоже рассказывал.

Та на здоровье, пусть приезжает :) Конечно можно достичь немеряных высот в сынтаксисе (и звдрочить текст до полной неузнаваемости) - но это никак не наполнит карман  :)
Р. Журден (не ручаюсь за точность цитаты)

Опять крайности? "Немеряные" высоты? Ах эти комплексы, комплексы... :)
Какой вы противоречивый человек, то все читающие букварь недопрограммисты-зубрежники, а тут смотри, нужно просто букварь прочесть и ты уже "профи на коне". :)
Главное читать букварь попроще, что бы для вас он был доступен. ;)

Вот именно, даже Журден Вам это говорит..

От себя добавлю, что гарантия написания полезных и качественных программ напрямую зависит от знания программиста своего инструментария и от его способности к обучаемости и новым возможностям как языка, так и инструмента (stl, boost, Qt, et.al.).  

Но Вы это демонстративно отвергаете чуть ли ни в каждом своём посте..
От чего сие?)      

Поверьте, эта зависимость далеко не прямая, она очень извилистая, и часто (увы) обратно-пропорциональная. Да-да, чем больше человек знает - тем хуже результат. Ну конечно если вообще ни хрена не знает - для работы непригоден. Но если слишком много знает - это еще хуже  :)

Это потому что вы на его фоне начинаете себя чувствовать некомпетентным? Хотите поговорить об этом?

Много знаний - много печалей.

К примеру если взять обычную программку - по паттерну строит файл с заменяемыми полями.

Творение юного и незнающего - за 15 минут с использованием QString.arg(), заменяемые значения пишутся в файле настройки через таб. Работает.

Творение программиста с опытом разработки систем - за день, использует буст и самописные библиотеки, которые не поставляются с исходниками программы. Вместо одной - две программы, консольная и с ГУИ. Имеет два файла настроек с xml структурой, вложенными параметрами, многопоточно, имеет отдельный файл настройки стиля. Все увязано try/cath, интерфейс чрезвычайно запутан, но без сомнения имеет настройки на все случаи жизни.

Что лучше? Филосовский вопрос.

Не хватает еще одного персонажа, которому лучше всех. Это уборщица баба Маша, вот уж у кого нет печали. Вот к чему нужно стремиться, печалей нет, деньги получает - профи же.

Вы куда то в дебри полезли. Мы о знаниях говорим и результате в виде программы, а не о "получать бабло".

PS мда, тяжеловато после отсутствия понять ход ваших мыслей.

http://lib.meta.ua/book/15955/

Хорошо, давайте другой пример. :)
Есть библиотека, написанная несомненно людьми с большим опытом разработки. В ней есть все что надо и что не надо: многозадачность, низкоуровневая поддержка сети, есть поддержка на уровне сетевых протоколов, умеет работать с камерами и мультимедиа, есть серьезная поддержка скриптов, WebKit, и GUI она умеет, и OpenGL, мощный графический фрейворк, а также умеет анимацию и Бог знает еще что.
Вы говорили, что тот программист написал вместо одной программы две, эти пошли дальше, они написали linguist, designer и assistant, а потом добили всех QtCreator. Этим монстрам даже не хватило просто компилятора C++ и они написали еще moc. И они надеются, что этим кто-то будет пользоваться. :)
Да мы все возьмем SDL, скачаем какую нибудь библиотеку GUI, сделанную школьником и будем без печали работать. Качать несколько мегабайт, собирать ее пару минут и вот оно счастье.
:)

И при этом сравните время и усилия, затраченные на их создание :)
Собственно всё ведёт к КПД = результат/(время + затраты).

Нужно вовремя остановиться. Есть крайности.
Qt не имеет полного покрытия функционала :) Собственно они остановились в правильной точке и выставили на рынок.

А если продолжить их дело, сделать компоненты для ввода символа, ввода простых чисел, вычисления интегралов, рисования графиков и прочего - получится перенасыщенный продукт и только через пару лет.

PS если вы не видите в моих ответах смысла, скажите мне об этом и я прекращу :)

Понимаете, вы пытаетесь найти смысл от ежеминутного использования простого решения. А представьте, что разрабатывается сложный проект с временем жизни десятки лет. Вы используете простое решение в начале, но по мере развития проекта, простое решение перестает устраивать и приходит время его заменить на сложное решение. И эта замена может быть очень не легка.
Поэтому, мы сразу выбираем сложное решение профессионала, в надежде что с ним не возникнет хлопот в дальнейшем. :)

Ну как сказать. Мы у разных сторон.

Вы смотрите на 10 лет вперед и для вас год-два разработки не имеют особого значения.

Я смотрю на день назад - когда надо вчера. И для меня первостепенно время и порог вхождения.

PS давайте закончим наш спор выводом - надо смотреть на конкретные потребности каждого проекта ^.^

Я себя отлично чувствую, но давайте говорить о программировании, а не о чуствах  :)

Вот std::thread - хорошо, вполне возможно есть проект без Qt, но кросс-платформенность нужна. Прошу показать как отследить завершение запущенной нитки.

Если вы выйдите из пещеры вы ужаснетесь от их числа. :)

Так же как это сделано в Qt, установкой флажочка. :)

А чего код не предъявляем? Видать забылось - или еще не прочиталось. Все эти std::знания напоминают мне
:)

Я не думал, что вы настолько беспомощны.  ::)

C++ (Qt)
m_finished = true;
 

Не наблюдаю такого http://en.cppreference.com/w/cpp/thread/thread (http://en.cppreference.com/w/cpp/thread/thread)

А вы хотите, что бы стандартная библиотека за вас и код нитки писала? Зовите "Двоих из ларца, одинаковых с лица". :)

2Igors Потратил на вас немного времени и набросал небольшой пример:
ВНИМАНИЕ! Это пример, не надо у меня спрашивать почему здесь нет средств синхронизации. /* А то сейчас из пальца проблемы будем высасывать. */ :)
Использовал буст, ибо собирается и без нового стандарта, заинтересованные могут переписать пример сами.

C++ (Qt)
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <iostream>
 
class Thread
{
public:
        Thread() : m_finished( true ) {}
 
        void    start()
        {
                m_th.reset( new boost::thread( boost::bind( &Thread::thread_func, this ) ) );
        }
 
        void    wait()
        {
                m_th->join();
        }
 
protected:
        virtual void    run()
        {
                std::cout << "Child thread-id = " << boost::this_thread::get_id() << std::endl;
        }
 
private:
        boost::shared_ptr<boost::thread>                m_th;
        bool                    m_finished;
 
        void    thread_func()
        {
                m_finished = false;
                run();
                m_finished = true;
        }
};
 
 
int main()
{
        std::cout << "Main thread-id = " << boost::this_thread::get_id() << std::endl;
 
        Thread t;
        t.start();
        t.wait();
 
        return 0;
}
 

Понимаю, насколько это сложный пример для вас, поэтому понимания не жду. :)

По-моему он просто неправильный  :)

C++ (Qt)
Thread t;
t.start();
if (t.m_finished)
 printf("Уже? :-)");
 

Ну и все-таки мы говорим об std (а не о бусте). Может так

C++ (Qt)
 
    std::thread th(foo);
    if (th.get_id() == std::thread::id())
     printf("finished");
 

?

Ну так это по вашему. Но вы в очередной раз заблуждаетесь. ;)

А что по вашему сделает этот код? :)

Давайте посмотрим кто заблуждается
Гарантируется что thread_func будет выполняться в созданной нитке. Но когда выполнится первая строка - хз, возможно нитка будет немедленно вытеснена, и m_finished все еще true когда главная его прочитает. Нужно перенести присвоение в start, и лучше оформить это как m_isRunning

Не знаю. Прочитал это
Я так понял что когда нитка завершится ее id будет равно дефаулту. Так это или нет - почему бы не спросить знатоков std? Сам лично этой частью std никогда не пользовался. Без Qt юзаю старую обертку для запуска ниток для Вындоуз и Unix (досталась в наследство) которая делает все что мне надо.

По поводу std - я ж не против, как видите, охотно наблюдаю (боковым зрением). Мне толкуют надо осваивать новые технологии, а то отстанешь от жизни и все такое. Ладно, задаю ПРОСТЕЙШИЙ, напрашивающийся вопрос  - и что? Один сразу нырнул в дуст (наверное привык там делать), а другого вообще как ветром сдуло :) Выходит вся ота "грамотность" - чисто понты, пролистать и попытаться запомнить как можно больше. Или я ошибаюсь?  :)

Давайте.
В своем посте я специально для вас написал следующую строку:
Я понимаю что вы ее не прочли (или не поняли).
Поэтому, если вы добавите некоторые средства синхронизации, а без них это просто демонстрашка, которую в реальный код вставлять и близко нельзя, то увидите, что этот код заработает верно, всегда!
Оставляю вам это в качестве домашнего задания, заодно посмотрите какие есть средства синхронизации потоков в стандартной библиотеке, уверен что вас некоторые моменты очень удивят.
Если не получиться - пишите, я покажу как это можно сделать.

Да, на вас уже жалко смотреть, такой вы беспомощный. В стандарт (std) все перешло как раз из boost, вышеприведенный пример переделывается на std за несколько минут. :( Да и не нужно его переделывать, это была демонстрация одного из вариантов реализации флага состояния нитки. В боевых проектах и класса такого никто делать не будет.

Но вам проще сигнал finished в азбуке искать и финдреплейсы для QString клепать. Понимаю, для этого думать особо не нужно. :)
К сожалению, это уже особо никому не интересно, скорее всего поэтому:

Вся ваша "грамотность" это чисто понты. Все правильно вы говорите.
Вы не можете найти элементарных решений, а виноваты все вокруг. Сплошные  комплексы. :)

Old, ну чего Вы разоряетесь и переходите на личности? Я же не виноват что Ваш пример, оказывается, "ненастоящий" :) Если std так хорош, то чего же для простейшей вещи Вы привлекли буст, а поверх еще и неудачный велосипед? Спасибо конечно что потратили время, но ей-богу, на голом API платформы выходит куда проще. Чего же Вы пытаетесь меня стыдить незнанием std, если на деле выясняется что сами-то знаете это место "примерно в мою силу"?  :)

Он не "настоящий" и лишен всяких обвесов, только для того, что бы была понятна суть. :)
И показывает, насколько просто решается ваша "проблема", до чего вы сами додуматься не смогли.

Потому, что новый стандарт только приняли, а бустом я пользуюсь уже многие годы. Мне было проще показать с его помощью. Хотя там для показания самой идеи ни std, ни boost и не нужен. :)

Демонстрация же, ну. Пример. :)
А так да, отдельные нитки на каждый чих запускать не комильфо, есть более удачные решения. Да. Но вам оно не нужно, не финдреплейс же. :)

Где код на голом API? Или забыли, или просто код перешел по наследству, а что там и как вы не знаете. Прошу исполнить. :)

Только сдается мне, что пока какой нибудь новичок новую тему про финдреплейс не откроет, кода мы от вас не увидим. :)
Это на в букваре про сигналы читать про библиотеку, где все за вас уже сделали. :)

Igors
Поддержка многопоточности в std пришла из boost'а (boost - это как некий полигон для стандарта) + ко всему прочему в c++11 появилась новая модель памяти.. Вот одна из цикла статей на эту тему: http://scrutator.me/post/2012/08/28/parallel-world-p3.aspx (http://scrutator.me/post/2012/08/28/parallel-world-p3.aspx) 

Те средства, что предоставляет сейчас для работы с многопоточностью стандартная библиотека или boost, оттачивались временем и далеко не дилетантами в этой области..  Если бы это было не перспективно, не удобно и не эффективно, это бы не прижилось ни в boost'е и не в std.

Но для вас, конечно же, это всё не аргумент..  И boost и сандартная библиотека - это плод чисто теоретиков от программирования) 
Куда уж им до "реальных" задач?) 

Скукатень, ни слова про финдреплейс для QString и где finished? Где? Очередные бредни зубрежников-непрофессионалов. :)

;D Ну да.. да.. Да, не всем дано проникнуться в образ мышления великого практика) Блоху от "практического программирования" подковать - это вам ни в boost  и во всякие сомнительные околоплюсовые статьи вникать, написанные хрен знает кем..) и хз знает для кого) И вообще..)

А Вы пытались хоть как-то осмыслить эту статью? Дочитайте до слов "компилятор имеет полное право". Оказывается если мы присваиваем член структуры, он скопирует всю, изменит член в локальной копии и потом всю присвоит!!! Да это же чушь собачья. Однако Вы осторожно молчите, и длиннющая лапша свисает с Ваших ушей  :)

С этим соображением здравого смысла никто не спорит. Острой необходимости в std нет, каждый использует то что знает. К сожалению, получается разнобой. Вот что я скажу др человеку работающему над проектом? Ставь tbb? Или "вот наша либа, пользуй ее"? Это не смертельно, но вызывает ненужные заботы. А с std таких проблем не возникает, может это его главное достоинство.

Ну так и показываем как же это в std. Был задан абсолютно безобидный и естественный вопрос - как пощупать нитку что она работает? Чего Вы так раздражаетесь. кто же виноват что Ваш запас прочитанных знаний уже иссяк на первом же вопросе?  :)

Я то как раз и прочёл и осмыслил.. А вот вы похоже остановились лишь на первом же пункте "Базовая модель".
То о чём Вы сейчас написали имело место в старом 03 стандарте, в котором нет многозадачности..
Пример, что приведён в той статье как раз демонстрирует, одну из причин по которой в новом 11 стандарте пришла на смену новая модель памяти..


Да просто Ваши вопросы из ряда: У слона длинный хобот и большие уши - почему он не летает?) 

А вам уже все показали, пример из варианта boost в вариант std переделывается за пять минут, просто небольшими косметическими изменениями пространства имен и подключаемых файлов. Если бы вы хотели это узнать, то давно бы переделали его сами, а если бы у вас что-то не получалось, то вам бы уже давно помогли. :)
Но вам оно не надо, или вы хотите получить готовое решение не подумав. Ну хотите дальше.

Вы попытались исправить мой класс перенеся присвоение и переименовав переменную :), но у него остались те же проблемы, что и ранее (только вид сбоку). Флажок нужно менять там, где я написал, только нужны некоторые дополнительные средства. Додуматься до решения вы так и не смогли, свой код (а точнее перешедший по наследству) организации потока, так же не предоставили. Скорее всего из-за того, что не особо знаете что копипастить.

Все как всегдап, сплошное бла-бла-бла и демонстрация Hello world. Скучно. Ждите новичков и показывайте им свой "проффесионализм". Х:)
 

Вот, специально для Вас реализация std (Хотя Old вам уже приводил пример, не знаю чего вам ещё надо):

C++ (Qt)
#include <iostream>
#include <atomic>
#include <memory>
#include <thread>
 
template <class Function>
class runable
{
public:
    typedef std::atomic_bool atomic_bool;
 
    runable(Function && f, atomic_bool & finished) : m_f(f), m_finished(finished) {}
    void operator()() const {
        m_f();
        m_finished = true;
    }
private:
    Function m_f;
    atomic_bool & m_finished;
 
};
 
class thread
{
public:
    typedef std::atomic_bool atomic_bool;
 
    template <class Function>
    thread(Function && f) : m_finished(false) {
       m_thread_ptr =  std::make_shared<std::thread>(runable<Function>(f, m_finished));
    }
 
    void join() { m_thread_ptr->join(); }
 
    bool fnished() const { return m_finished; }
private:
    atomic_bool m_finished;
    std::shared_ptr<std::thread> m_thread_ptr;
};
 
 
void func() {
    std::cout << " Child thread-id = " << std::this_thread::get_id() << std::endl;
}
 
int main()
{
    std::cout << "Main thread-id = " << std::this_thread::get_id() << std::endl;
 
    thread th(func);
 
    while (!th.fnished()) {}
 
    std::cout << "finished!\n";
 
    th.join();
    return 0;
}
 

Весь трагизм ситуации в том, что мы сейчас "плохому учим". :)
Мы породили совершенно ненужную сущность и демонстрируем реализацию совершенно бесполезного действия, которое вряд-ли когда понадобиться в реальном проекте.
В боевых условиях, если мне понадобиться дождаться завершения одного действия, что бы выполнить другое, я воспользуюсь другим более эффективным средством для этого.
Но что бы наш "профи" понял этот шайтан-прием, приходится идти на это. :)

Сейчас я занят с пытоном, когда буду посвободнее - создам тему где это обсудим. Не возражаете?

Объясните что это за байда и зачем она нужна. Да, и если Вы делаете прокладку (runnable) то как ее сделать для разных пользоваткльских ф-ций (с разеыми параметрами)? Спасибо

Этим приемом я владею не хуже Вас и детских ошибок не допускаю :) Только вот мне не очень интересно тратить время на изучение, а потом еще и класс создавай, и флажок заводи  :'( Хочется "попастись", попользоваться готовым (если уж изучал). Это нормальное шкурное желание, а здесь (std) что-то не густо.

Насчет того что никогда не понадобится это Вы загнули. Ну хорошо, показываем а как же мне получить завершение по асинхронке - callback или там future какой (ну все, хана, щас затопчут сынтаксысом  :))

Да пожалуйста, только если вопросы будете корректные ставить..

А Вы сами как думаете?

Точно так же как это сделано в std::thread.. Можно вообще ничего не менять в runable, передавая в него любую функцию с любым числом параметров.. но.. Но для этого нужно знать что такое и как работает std::bind.. Понимаю - не вариант для Вас)

Да, и Ваш пример не компилится

Не придумывайте, вы до сих пор не знаете как это сделать, иначе мы бы увидели ваше чудо решение уже давно.
Повторяю, то что предлагаете вы (перенести присвоение в start и переименовать переменную) - ничего не исправляет!
Устанавливать переменную нужно там, где это делаю я, нужно просто добавить некоторые средства синхронизации, и все заработает как надо. Но у вас не получается....

Конечно - это идиотизм, так никто не делает, так же как и не узнает завершилась ли нить или нет. :) Это идиотское решение для вашей идиотской задачи. Все нормально.

Так а почему не пользуетесь? Вы сейчас изобрели кастрированный QThreadPool + QRunnable. Почему вы не воспользовались готовым? Еще не изучили? А на базе этого решения и строятся QtConcurent.

Конечно не густо, вы уставились на низкоуровневый std::thread и хотите от него сигнала finished. Он так не умеет.
Нужны другие средства, на его основе.

Запускать одинарные потоки можно если в программа ИНОГДА нужно сделать какую-то асинхронную операцию (или в софте для секретарш), если программа активно работает с потоками, то нужно создавать пул потоков, в котором они запускаются один раз и выполняют появляющиеся задачи. Кстати в Qt так и сделано.
Я использую свой пул потоков, основанный на бусте, там я могу запустить любую функцию или любой метод любого объекта в отделном потоке и по завершению получить от него результат. Никаких ограничений не на количество длинных операций, ни на их длительность нет.
Наследоваться не от чего не надо, никаких QRunnable (и самодельные интерфейсов), там нет и в помине.
Можете вызвать функцию непосредственно, а можете ее же в отдельной нитке, делается это в одну строку.

Мне никогда не понадобиться.
А синтаксис очень прост:

C++ (Qt)
void setvar::execute( connection_ptr c )
{
        calc::longops::instance()->start(
                boost::bind( &recalc, c->get_context(), boost::ref( m_vars ) ),    // Запустить recalc в отдельной нитке
                boost::bind( &setvar::send_reply, shared_from_this(), c, _1 )      // После завершения выполнения вызвать send_reply.
               // В качестве аргумента send_reply будет передан результат выполнения recalc.
        );
}
 

Понимаю, для вас сынтаксис сложноват, но уж такая у нас работа.

И да, вам бы с этим делом сначала в Qt разобраться, там и азбука получше, да и сделано там попроще, сильно C++ знать не надо. Все как вы любите. :)

Классика советского кино
С Вами хорошо в карты играть  :)

Никто и не сомневался что в бусте это есть. Но мы говорим об std (голый стандарт). Поэтому пожалуйста по теме

Со мной блефовать будет сложно. :) Не получиться в "уши надуть"  про свои якобы умения. ;)

Так в std уже bind есть, можно вместо boost:: написать std:: Неужели это так сложно для вас?
Под "основанный на boost" имеется ввиду, что для реализации используются средства boost, т.к. раньше нужные мне вещи были только там.
Внутри у моего решения, только потоки, средства синхронизации, std::list + std::queue, function, ну и bind. И конечно умные указатели. Все это есть в C++11, то есть в std.

Сел переделал решение для std, теперь и без буста. :)

Так а где же оно?  :)

У меня в директории thread_pool. :)

Что бы оценить размер этой шайтан-штуки привожу небольшой скриншотик (120 строк кода вместе с пустыми строками). :)
При конструировании стартует/при разрушении останавливает нитки, их количество можно задать руками, а можно оставить ей, тогда запуститься std::thread::hardware_concurrency() ниток. Устанавливает задачи в очередь, выполняет и сообщает кому велено результат. :)

m_ax, хотел создать новую тему чтобы обсудить эту статью (как и обещал). Но почему-то первоисточник удален (404). Может перенесли в др место? (хотя скорее всего разобрались что фуфло и замочили чтобы не позориться  :))

Что за фантазии?) Ничего не удалён) У меня всё кликабельно.

Ага, у меня теперь тоже все норм. Ладно, создаю  :)