Russian Qt Forum

C++ (Qt)
void MyClass::methodForSync(void) {
  ...
}
 
void MyClass::doAny(void) {
  ...
  ...
  sb_synchronize_method(MyClass, methodForSync);
  ...
  ...
}

C++ (Qt)
//---------------------------------------------------------------------------
 
#ifndef sbw_kernelH
#define sbw_kernelH
 
//---------------------------------------------------------------------------
 
#include <QObject>
#include <QApplication>
#include <QThread>
#include <QWaitCondition>
#include <QMutex>
 
/*-----------------------------------------------------------------------------*/
 
class SbThread;
class SbThreadSync;
class SbApplication;
 
/*-----------------------------------------------------------------------------*/
 
class SbThread : public QThread {
    Q_OBJECT
  protected:
    QAtomicInt Stopped;
    QMutex Mutex;
    QWaitCondition Wait;
    SbApplication* Application;
  public:
    SbThread(bool FreeOnComplete = false, QObject * parent = 0);
    virtual ~SbThread();
 
    inline bool stopped (void) const {return Stopped;}
    inline void stop    (void) {Stopped.ref();}
    void wake (void);
 
  public:
    static void synchronize(SbThreadSync* s);
 
  protected:
    void doSynchronize(SbThreadSync* s);
 
  signals:
    void signalSynchronize(SbThreadSync* s);
 
};
 
/*-----------------------------------------------------------------------------*/
 
class SbThreadSync {
    friend class SbThread;
    friend class SbApplication;
  private:
    SbThread* Thread;
  protected:
    void syncCall(void);
  public:
    SbThreadSync() {Thread = NULL;}
    virtual ~SbThreadSync() {}
 
    virtual void call(void) = 0;
};
 
#define sb_synchronize_method(__type, __method) \
  { \
    class TrSync : public SbThreadSync { \
      private : \
        __type* obj; \
        void (__type::*method)(void); \
      public : \
        TrSync(__type* obj, void (__type::*method)(void)): SbThreadSync() {this->obj = obj; this->method = method;} \
        void call (void) {(obj->*method)();} \
    } trs(this, &__type::__method); \
    SbThread::synchronize(&trs); \
  }
 
/*-----------------------------------------------------------------------------*/
 
class SbApplication : public QApplication {
    Q_OBJECT
  public:
    static QThread* thread(void) {return QApplication::instance()->thread();}
  public:
    SbApplication(int& argc, char** argv) : QApplication(argc, argv) {} 
 
  private slots:
    void synchronize(SbThreadSync* s) {s->syncCall();}
};
 
#endif
 

C++ (Qt)
/*-----------------------------------------------------------------------------*/
 
#include "sbw_kernel.h"
 
/*-----------------------------------------------------------------------------*/
 
 /***************************
 *     class SbThread
 ***************************/
 
SbThread::SbThread(bool FreeOnComplete, QObject* parent) : QThread(parent) {
  Stopped = 0;
  if(FreeOnComplete) {connect(this , SIGNAL(finished()), this , SLOT(deleteLater()));}
  SbApplication* Application = qobject_cast<SbApplication*>(QApplication::instance());
  if(Application)    {connect(this , SIGNAL(signalSynchronize(SbThreadSync*)), Application, SLOT(synchronize(SbThreadSync*)), Qt::QueuedConnection);}
}
 
SbThread::~SbThread() {
}
 
void SbThread::wake (void) {
  Wait.wakeOne();
}
 
void SbThread::doSynchronize(SbThreadSync* s) {
  Mutex.lock();
  emit signalSynchronize(s);
  Wait.wait(&Mutex);
  Mutex.unlock();
}
 
void SbThread::synchronize(SbThreadSync* s) {
  if(SbApplication::thread() == QThread::currentThread()) {
    s->call();
    return;
  }
  SbThread* Thread = qobject_cast<SbThread*>(QThread::currentThread());
  if(!Thread || !Thread->Application) {
    s->call(); // OR throw
    return;
  }
  s->Thread = Thread;
  Thread->doSynchronize(s);
}
 
/*-----------------------------------------------------------------------------*/
 
 /***************************
 *     class SbThreadSync
 ***************************/
 
void SbThreadSync::syncCall(void) {
  call();
  Thread->wake();
}
 
/*-----------------------------------------------------------------------------*/
 

• Цитата: alexman от Июль 15, 2009,  22:13
  Например, можно послать сигнал из вспомогательного потока главному на создание QWidget и уснуть на QWaitCondition (метод bool wait ( QMutex * mutex, unsigned long time = ULONG_MAX )). Далее в главном окне что-то делаем с QWidget, а по завершению вызываем метод второстепенного потока из главного, в котором делаем wakeOne.
  
  • Во-первых, help по Qt::ConnectionType.
    
  • Во-вторых, низкоуровневые примитивы вроде QMutex,QAtomicInt и.т.п. в прикладном коде следует всячески избегать, т.к. при наличии QtConcurrent они тупо практически никогда не нужны, а если и нужны, то часто есть более лучшие решения без них.
    
  • В-третьих, что будет
    Поток A шлет сигнал главному потоку сигнал  на создание QWidget и засыпает.
    Поток B шлет сигнал главному потоку сигнал  на создание QWidget и засыпает.
    Главный поток создает QWidget по запросу потока А и делает wakeOne.
    Вопрос? Какой поток проснется A или B.
    
  Цитировать
  void QWaitCondition::wakeOne ()
  Wakes one thread waiting on the wait condition. The thread that is woken up depends on the operating system's scheduling policies, and cannot be controlled or predicted.
  If you want to wake up a specific thread, the solution is typically to use different wait conditions and have different threads wait on different conditions.
  See also wakeAll().
  
  
  

C++ (Qt)
void SbThread::wake (void) {
  Mutex.lock();
  Wait.wakeOne();
  Mutex.unlock();
}
 
void SbThread::doSynchronize(SbThreadSync* s) {
  Mutex.lock();
  emit signalSynchronize(s);
  Wait.wait(&Mutex);
  Mutex.unlock();
}