Qt多线程的创建及使用方法_qt5多线程创建一定要放在主线程中2吗-程序员宅基地

技术标签： QT

参考：http://blog.csdn.net/rl529014/article/details/52815341

在上一篇文章中，转载了Qt创建多线程的两种方法，分别是继承QThread和继承QObject，文章较长，看得有点晕，但理论性比较全面，所以记录下来

本文通过最简单、最常用的方法，来实现多线程的创建，至于提到的其它问题，再慢慢优化吧

多线程的特点：

1、多个线程共享进程的内存空间，多线程内存空间统一。

2、每个线程都有自己独立的栈空间，多个线程之间是相互独立的。

3、线程是操作系统运算调度的最小单位。

4、进程支持多线程，但是必须有一个主线程。

5、子线程都是通直接或者间接的通过主线程启动。

6、主线程结束，所有子线程也会结束。

常用函数：

MoveToThread();

CurrentThread(),返回当前线程的指针。

CurrentThreadId(),返回当前线程的句柄。

生存线程：线程被创建时，该线程所在的线程。

注意：

多线程不是必须的，大多数情况下，一个主线程就可以完成相应的工作。

线程越多，对系统造成的负担越大。

实现多线程的方法：

1、Qthread（传统方法）：继承自Qthread，实现run()函数，执行Qthread的start函数，线程开始执行。

2、Qtconcurrt（高级API，更加方便使用）

例：

下面以继承QThread,重写run()函数为例

功能：在主线程中创建两个子线程，点击start和stop分别开始和结束打印文本。

ui文件主界面：

先看效果图：

源码：

//main.cpp


    
    
     
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QApplication> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QDebug> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include "threaddialog.h"  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QThread> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         int main(int argc, char *argv[])  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         QApplication a(argc, argv);  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            ThreadDialog dialog ;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            dialog.show();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         return a.exec();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }

//thread.h


    
    
     
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #ifndef THREAD_H  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #define THREAD_H  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QThread> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QtCore> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QObject> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QMutex> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <iostream> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         using 
        
        
         namespace 
        
        
         std;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         class Thread : 
        
        
         public QThread  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Q_OBJECT  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         public:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Thread();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void setMessage(const QString &message);  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void stop();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         private slots:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void run();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         private:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            QString messageStr;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         volatile 
        
        
         bool stopped;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        };  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #endif // THREAD_H

//thread.cpp


    
    
     
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include "thread.h"  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QTimer> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QMutexLocker> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        Thread::Thread()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            stopped = 
        
        
         false;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void Thread::setMessage(
        
        
         const QString &message)  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            messageStr = message;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void Thread::stop()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            stopped = 
        
        
         true;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void Thread::run()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         while(!stopped)  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                qDebug()<<messageStr;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            stopped = 
        
        
         false;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         std::
        
        
         cerr<<
        
        
         std::
        
        
         endl;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }

//threaddialog.h


    
    
     
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #ifndef THREADDIALOG_H  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #define THREADDIALOG_H  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QMainWindow> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include "thread.h"  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QPushButton> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QCloseEvent> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         namespace Ui {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         class ThreadDialog;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         class ThreadDialog : 
        
        
         public QMainWindow  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Q_OBJECT  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         public:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         explicit ThreadDialog(QWidget *parent = 0);  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            ~ThreadDialog();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         protected:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void closeEvent(QCloseEvent *e);  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         private:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Thread threadA;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Thread threadB;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            QPushButton *threadABtn;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            QPushButton *threadBBtn;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            QPushButton *quitBtn;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         private slots:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void startOrStopThreadA();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void startOrStopThreadB();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         void on_quit_clicked();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         private:  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            Ui::ThreadDialog *ui;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        };  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #endif // THREADDIALOG_H

//threaddialog.cpp


    
    
     
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include "threaddialog.h"  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include "ui_threaddialog.h"  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         #include <QTimer> 
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        ThreadDialog::ThreadDialog(QWidget *parent) :  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            QMainWindow(parent),  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            ui(
        
        
         new Ui::ThreadDialog)  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            ui->setupUi(
        
        
         this);  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadA.setMessage(
        
        
         "I am A");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadB.setMessage(
        
        
         "I am B");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadABtn = 
        
        
         new QPushButton(
        
        
         "Start A");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadBBtn = 
        
        
         new QPushButton(
        
        
         "Start B");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            quitBtn = 
        
        
         new QPushButton(
        
        
         "Quit");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            connect(ui->threadABtn,SIGNAL(clicked(
        
        
         bool)),SLOT(startOrStopThreadA()));  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            connect(ui->threadBBtn,SIGNAL(clicked(
        
        
         bool)),SLOT(startOrStopThreadB()));  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        ThreadDialog::~ThreadDialog()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         delete ui;  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void ThreadDialog::closeEvent(QCloseEvent *e)  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadA.stop();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadB.stop();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadA.wait();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            threadB.wait();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            e->accept();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void ThreadDialog::startOrStopThreadA()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         if(threadA.isRunning())  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                threadA.stop();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                 ui->threadABtn->setText(
        
        
         "Start A");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         else  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                threadA.start();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                ui->threadABtn->setText(
        
        
         "Stop A");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void ThreadDialog::startOrStopThreadB()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         if(threadB.isRunning())  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                threadB.stop();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                ui->threadBBtn->setText(
        
        
         "Start B");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
            
        
        
         else  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                threadB.start();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
                ui->threadBBtn->setText(
        
        
         "Stop B");  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
            }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
          
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
        
        
         void ThreadDialog::on_quit_clicked()  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        {  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
             close();  
       
       
        
      
      
       
      
      
      
       
       
       
        
      
      
       
      
      
       
       
       
        
         
        
        }

源码下载：http://download.csdn.net/detail/rl529014/9657653

本文链接：https://blog.csdn.net/wu694128/article/details/93354362

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

fluent里常见基础问题（转）_fluent不同算法对结果影响-程序员宅基地

文章浏览阅读8.4k次，点赞9次，收藏104次。1　什么叫松弛因子？松弛因子对计算结果有什么样的影响？它对计算的收敛情况又有什么样的影响？　　1、亚松驰（Under Relaxation）：所谓亚松驰就是将本层次计算结果与上一层次结果的差值作适当缩减，以避免由于差值过大而引起非线性迭代过程的发散。用通用变量来写出时，为松驰因子（Relaxation Factors）。《数值传热学-214》　　2、FLUENT中的亚松驰：由于FLUENT所解..._fluent不同算法对结果影响

Application Loader上传中断，提示Cannot proceed with delivery: an existing transporter instance is currently_error: cannot proceed with delivery: an existing t-程序员宅基地

文章浏览阅读1k次。把Application Loader(XCode->Organizer->Archived Applications->Submit)中正在上传的文件中断或者删除，再次Submit提示：Cannot proceed with delivery: an existing transporter instance is currently uploading this package。无论如_error: cannot proceed with delivery: an existing transporter instance is cur

typescript的基本结构_Vue3.0 前的 TypeScript 最佳入门实践-程序员宅基地

文章浏览阅读111次。Vue3.0 前的 TypeScript 最佳入门实践前言其实Vue官方从2.6.X版本开始就部分使用Ts重写了。我个人对更严格类型限制没有积极的看法，毕竟各类转类型的骚写法写习惯了。然鹅最近的一个项目中，是TypeScript+ Vue，毛计喇，学之...…真香！注意此篇标题的“前”，本文旨在讲Ts混入框架的使用，不讲Class API1. 使用官方脚手架构建npm install -g @vu..._vue3.0 typescript目录结构

Science Advances: 中科院微生物所叶健团队揭示双生病毒调控植物免疫平衡制约机制...-程序员宅基地

文章浏览阅读601次。病毒，作为非细胞的生物形式，只能在活细胞内增殖，专性活细胞内寄生。我们居住的星球病毒数量惊人，大约有1031个，其基因头尾相连可长达2.5亿光年。现代微生物学的奠基人路易斯巴斯德用病毒（..._editor daniel j kliebenstein

Java导出Word文档(可设置字体)_java list数据生成word自定义字体大小和字体颜色-程序员宅基地

文章浏览阅读7.5k次。原作者：兰博基尼http://hujinfan.iteye.com/blog/847029导出内容导Word文档中，可设置字体，亲测可用。importjava.io.FileOutputStream;import java.io.IOException;import java.util.List;importcom.lowagie.text.Document;impo_java list数据生成word自定义字体大小和字体颜色

X1 grok-1 开源大语言模型下载_grok-1下载-程序员宅基地

文章浏览阅读795次，点赞11次，收藏4次。我们正在发布我们的大型语言模型 Grok-1 的基本模型权重和网络架构。Grok-1 是一个 3140 亿参数的专家混合模型，由 xAI 从头开始训练。_grok-1下载