精华内容
下载资源
问答
  • C++多线程

    千次阅读 2017-07-21 15:22:53
    C++多线程

    C++ 多线程

    本篇博客主要介绍C++ 的多线程机制。

    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下,两种类型的多任务处理:基于进程和基于线程。

    • 基于进程的多任务处理是程序的并发执行。

    • 线程的多任务处理是同一程序的片段的并发执行。

    多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程,每个线程定义了一个单独的执行路径。

    C++ 不包含多线程应用程序的任何内置支持。相反,它完全依赖于操作系统来提供此功能。

    本教程假设您使用的是 Linux 操作系统,我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用,比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

    创建线程

    下面的程序,我们可以用它来创建一个 POSIX 线程:

    #include <pthread.h>pthread_create (thread, attr, start_routine, arg) 

    在这里,pthread_create 创建一个新的线程,并让它可执行。下面是关于参数的说明:

    参数说明

    参数 说明
    thread 指向线程标识符指针。
    attr 一个不透明的属性对象,可以被用来设置线程属性。您可以指定线程属性对象,也可以使用默认值 NULL。
    start_routine 线程运行函数起始地址,一旦线程被创建就会执行。
    arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数,则使用 NULL。

    创建线程成功时,函数返回 0,若返回值不为 0 则说明创建线程失败。

    终止线程

    使用下面的程序,我们可以用它来终止一个 POSIX 线程:

    #include <pthread.h>pthread_exit (status) 

    在这里,pthread_exit 用于显式地退出一个线程。通常情况下,pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。

    如果 main() 是在它所创建的线程之前结束,并通过 pthread_exit() 退出,那么其他线程将继续执行。否则,它们将在 main() 结束时自动被终止。

    实例:
    以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程,每个线程输出"Hello Runoob!":

    #include <iostream>// 必须的头文件是#include <pthread.h>using namespace std;#define NUM_THREADS 5// 线程的运行函数,函数返回的是函数指针,便于后面作为参数  void* say_hello(void* args){    cout << "Hello Runoob!" << endl;}int main(){    // 定义线程的 id 变量,多个变量使用数组    pthread_t tids[NUM_THREADS];    for(int i = 0; i < NUM_THREADS; ++i)    {        //参数依次是:创建的线程id,线程参数,调用的函数,传入的函数参数        int ret = pthread_create(&tids[i], NULL, say_hello, NULL);        if (ret != 0)        {           cout << "pthread_create error: error_code=" << ret << endl;        }    }    //等各个线程退出后,进程才结束,否则进程强制结束了,线程可能还没反应过来;    pthread_exit(NULL);}

    使用 -lpthread 库编译下面的程序:

    $ g++ test.cpp -lpthread -o test.o

    现在,执行程序,将产生下列结果:

    $ ./test.oHello Runoob!Hello Runoob!Hello Runoob!Hello Runoob!Hello Runoob!

    以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程,并接收传入的参数。每个线程打印一个 "Hello Runoob!" 消息,并输出接收的参数,然后调用 pthread_exit() 终止线程。

    //文件名:test.cpp#include <iostream>#include <cstdlib>#include <pthread.h>using namespace std;#define NUM_THREADS     5void *PrintHello(void *threadid){     // 对传入的参数进行强制类型转换,由无类型指针变为整形数指针,然后再读取   int tid = *((int*)threadid);   cout << "Hello Runoob! 线程 ID, " << tid << endl;   pthread_exit(NULL);}int main (){   pthread_t threads[NUM_THREADS];   int indexes[NUM_THREADS];// 用数组来保存i的值   int rc;   int i;   for( i=0; i < NUM_THREADS; i++ ){            cout << "main() : 创建线程, " << i << endl;      indexes[i] = i; //先保存i的值      // 传入的时候必须强制转换为void* 类型,即无类型指针              rc = pthread_create(&threads[i], NULL,                           PrintHello, (void *)&(indexes[i]));      if (rc){         cout << "Error:无法创建线程," << rc << endl;         exit(-1);      }   }   pthread_exit(NULL);}

    现在编译并执行程序,将产生下列结果:

    $ g++ test.cpp -lpthread -o test.o$ ./test.omain() : 创建线程, 0main() : 创建线程, 1main() : 创建线程, 2main() : 创建线程, 3main() : 创建线程, 4Hello Runoob! 线程 ID, 4Hello Runoob! 线程 ID, 3Hello Runoob! 线程 ID, 2Hello Runoob! 线程 ID, 1Hello Runoob! 线程 ID, 0

    向线程传递参数

    这个实例演示了如何通过结构传递多个参数。您可以在线程回调中传递任意的数据类型,因为它指向 void,如下面的实例所示:

    #include <iostream>#include <cstdlib>#include <pthread.h>using namespace std;#define NUM_THREADS     5struct thread_data{   int  thread_id;   char *message;};void *PrintHello(void *threadarg){   struct thread_data *my_data;   my_data = (struct thread_data *) threadarg;   cout << "Thread ID : " << my_data->thread_id ;   cout << " Message : " << my_data->message << endl;   pthread_exit(NULL);}int main (){   pthread_t threads[NUM_THREADS];   struct thread_data td[NUM_THREADS];   int rc;   int i;   for( i=0; i < NUM_THREADS; i++ ){      cout <<"main() : creating thread, " << i << endl;      td[i].thread_id = i;      td[i].message = "This is message";      rc = pthread_create(&threads[i], NULL,                          PrintHello, (void *)&td[i]); //传入到参数必须强转为void*类型,即无类型指针      if (rc){         cout << "Error:unable to create thread," << rc << endl;         exit(-1);      }   }   pthread_exit(NULL);}

    当上面的代码被编译和执行时,它会产生下列结果:

    $ g++ -Wno-write-strings test.cpp -lpthread -o test.o$ ./test.omain() : creating thread, 0main() : creating thread, 1main() : creating thread, 2main() : creating thread, 3main() : creating thread, 4Thread ID : 3 Message : This is messageThread ID : 2 Message : This is messageThread ID : 0 Message : This is messageThread ID : 1 Message : This is messageThread ID : 4 Message : This is message

    连接和分离线程

    我们可以使用以下两个函数来连接或分离线程:

    pthread_join (threadid, status) pthread_detach (threadid) 

    pthread_join() 子程序阻碍调用程序,直到指定的 threadid 线程终止为止。当创建一个线程时,它的某个属性会定义它是否是可连接的(joinable)或可分离的(detached)。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的,则它永远也不能被连接。

    这个实例演示了如何使用 pthread_join() 函数来等待线程的完成。

    #include <iostream>#include <cstdlib>#include <pthread.h>#include <unistd.h>using namespace std;#define NUM_THREADS     5void *wait(void *t){   int i;   long tid;   tid = (long)t;   sleep(1);   cout << "Sleeping in thread " << endl;   cout << "Thread with id : " << tid << "  ...exiting " << endl;   pthread_exit(NULL);}int main (){   int rc;   int i;   pthread_t threads[NUM_THREADS];   pthread_attr_t attr;   void *status;   // 初始化并设置线程为可连接的(joinable)   pthread_attr_init(&attr);   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);   for( i=0; i < NUM_THREADS; i++ ){      cout << "main() : creating thread, " << i << endl;      rc = pthread_create(&threads[i], NULL, wait, (void *)i );      if (rc){         cout << "Error:unable to create thread," << rc << endl;         exit(-1);      }   }   // 删除属性,并等待其他线程   pthread_attr_destroy(&attr);   for( i=0; i < NUM_THREADS; i++ ){      rc = pthread_join(threads[i], &status);      if (rc){         cout << "Error:unable to join," << rc << endl;         exit(-1);      }      cout << "Main: completed thread id :" << i ;      cout << "  exiting with status :" << status << endl;   }   cout << "Main: program exiting." << endl;   pthread_exit(NULL);}

    当上面的代码被编译和执行时,它会产生下列结果:

    main() : creating thread, 0main() : creating thread, 1main() : creating thread, 2main() : creating thread, 3main() : creating thread, 4Sleeping in thread Thread with id : 4  ...exiting Sleeping in thread Thread with id : 3  ...exiting Sleeping in thread Thread with id : 2  ...exiting Sleeping in thread Thread with id : 1  ...exiting Sleeping in thread Thread with id : 0  ...exiting Main: completed thread id :0  exiting with status :0Main: completed thread id :1  exiting with status :0Main: completed thread id :2  exiting with status :0Main: completed thread id :3  exiting with status :0Main: completed thread id :4  exiting with status :0Main: program exiting.

    互斥锁的实现

    互斥锁是实现线程同步的一种机制,只要在临界区前后对资源加锁就能阻塞其他进程的访问。

    #include <iostream>#include <pthread.h>using namespace std;#define NUM_THREADS 5int sum = 0//定义全局变量,让所有线程同时写,这样就需要锁机制pthread_mutex_t sum_mutex; //互斥锁void* say_hello( void* args ){    cout << "hello in thread " << *(( int * )args) << endl;    pthread_mutex_lock( &sum_mutex ); //先加锁,再修改sum的值,锁被占用就阻塞,直到拿到锁再修改sum;    cout << "before sum is " << sum << " in thread " << *( ( int* )args ) << endl;    sum += *( ( int* )args );    cout << "after sum is " << sum << " in thread " << *( ( int* )args ) << endl;    pthread_mutex_unlock( &sum_mutex ); //释放锁,供其他线程使用    pthread_exit( 0 );}int main(){    pthread_t tids[NUM_THREADS];    int indexes[NUM_THREADS];    pthread_attr_t attr; //线程属性结构体,创建线程时加入的参数    pthread_attr_init( &attr ); //初始化    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能    pthread_mutex_init( &sum_mutex, NULL ); //对锁进行初始化    forint i = 0; i < NUM_THREADS; ++i )    {        indexes[i] = i;        int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) ); //5个进程同时去修改sum        if( ret != 0 )        {            cout << "pthread_create error:error_code=" << ret << endl;        }    }    pthread_attr_destroy( &attr ); //释放内存    void *status;    forint i = 0; i < NUM_THREADS; ++i )    {        int ret = pthread_join( tids[i], &status ); //主程序join每个线程后取得每个线程的退出信息status        if( ret != 0 )        {            cout << "pthread_join error:error_code=" << ret << endl;        }    }    cout << "finally sum is " << sum << endl;    pthread_mutex_destroy( &sum_mutex ); //注销锁}

    测试结果:

    hello in thread hello in thread 1hello in thread 30hello in thread 2before sum is 0 in thread 1hello in thread 4after sum is 1 in thread 1before sum is 1 in thread 3after sum is 4 in thread 3before sum is 4 in thread 4after sum is 8 in thread 4before sum is 8 in thread 0after sum is 8 in thread 0before sum is 8 in thread 2after sum is 10 in thread 2finally sum is 10

    可知,sum的访问和修改顺序是正常的,这就达到了多线程的目的了,但是线程的运行顺序是混乱的,混乱就是正常?

    信号量的实现

    信号量是线程同步的另一种实现机制,信号量的操作有signalwait,本例子采用条件信号变量

    pthread_cond_t tasks_cond;

    信号量的实现也要给予锁机制。

    #include <iostream>#include <pthread.h>#include <stdio.h>using namespace std;#define BOUNDARY 5int tasks = 10;pthread_mutex_t tasks_mutex; //互斥锁pthread_cond_t tasks_cond; //条件信号变量,处理两个线程间的条件关系,当task>5,hello2处理,反之hello1处理,直到task减为0void* say_hello2( void* args ){    pthread_t pid = pthread_self(); //获取当前线程id    cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;    bool is_signaled = false//sign    while(1)    {        pthread_mutex_lock( &tasks_mutex ); //加锁        if( tasks > BOUNDARY )        {            cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;            --tasks; //modify        }        else if( !is_signaled )        {            cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;            pthread_cond_signal( &tasks_cond ); //signal:向hello1发送信号,表明已经>5            is_signaled = true//表明信号已发送,退出此线程        }        pthread_mutex_unlock( &tasks_mutex ); //解锁        if( tasks == 0 )            break;    }}void* say_hello1( void* args ){    pthread_t pid = pthread_self(); //获取当前线程id    cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;    while(1)    {        pthread_mutex_lock( &tasks_mutex ); //加锁        if( tasks > BOUNDARY )        {            cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;            pthread_cond_wait( &tasks_cond, &tasks_mutex ); //wait:等待信号量生效,接收到信号,向hello2发出信号,跳出wait,执行后续        }        else        {            cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;            --tasks;        }        pthread_mutex_unlock( &tasks_mutex ); //解锁        if( tasks == 0 )            break;    }}int main(){    pthread_attr_t attr; //线程属性结构体,创建线程时加入的参数    pthread_attr_init( &attr ); //初始化    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能    pthread_cond_init( &tasks_cond, NULL ); //初始化条件信号量    pthread_mutex_init( &tasks_mutex, NULL ); //初始化互斥量    pthread_t tid1, tid2; //保存两个线程id    int index1 = 1;    int ret = pthread_create( &tid1, &attr, say_hello1, ( void* )&index1 );    if( ret != 0 )    {        cout << "pthread_create error:error_code=" << ret << endl;    }    int index2 = 2;    ret = pthread_create( &tid2, &attr, say_hello2, ( void* )&index2 );    if( ret != 0 )    {        cout << "pthread_create error:error_code=" << ret << endl;    }    pthread_join( tid1, NULL ); //连接两个线程    pthread_join( tid2, NULL );    pthread_attr_destroy( &attr ); //释放内存    pthread_mutex_destroy( &tasks_mutex ); //注销锁    pthread_cond_destroy( &tasks_cond ); //正常退出}

    测试结果:
    先在线程2中执行say_hello2,再跳转到线程1中执行say_hello1,直到tasks减到0为止。

    [2] hello in thread 1[2] pthread_cond_signal in thread 1[3] hello in thread 2[3] take task: 10 in thread 2[3] take task: 9 in thread 2[3] take task: 8 in thread 2[3] take task: 7 in thread 2[3] take task: 6 in thread 2[3] pthread_cond_signal in thread 2[2] take task: 5 in thread 1[2] take task: 4 in thread 1[2] take task: 3 in thread 1[2] take task: 2 in thread 1[2] take task: 1 in thread 1

    C++ 11中的多线程技术

    C++11 新标准中引入了四个头文件来支持多线程编程,他们分别是 <atomic> ,<thread>,<mutex>,<condition_variable><future>

    • <atomic>:提供原子操作功能,该头文主要声明了两个类, std::atomic 和 std::atomic_flag,另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。

    • <thread>:线程模型封装,该头文件主要声明了 std::thread 类,另外 std::this_thread 命名空间也在该头文件中。

    • <mutex>:互斥量封装,该头文件主要声明了与互斥量(mutex)相关的类,包括 std::mutex 系列类,std::lock_guard, std::unique_lock, 以及其他的类型和函数。

    • <condition_variable>:条件变量,该头文件主要声明了与条件变量相关的类,包括 std::condition_variable 和 std::condition_variable_any。

    • <future>:实现了对指定数据提供者提供的数据进行异步访问的机制。该头文件主要声明了 std::promise, std::package_task 两个 Provider 类,以及 std::future 和 std::shared_future 两个 Future 类,另外还有一些与之相关的类型和函数,std::async() 函数就声明在此头文件中。

    简单示例:

    #include <iostream>#include <thread>using namespace std;void thread_1(){    cout << "hello from thread_1" << endl;}int main(int argc, char **argv){    thread t1(thread_1);    /**    join()相当于调用了两个函数:WaitForSingleObject、CloseHandle,事实上,在vc12中也是这么实现的    */    t1.join();    return 0;}

    注意事项

    1. 若线程调用到的函数在一个类中,则必须将该函数声明为静态函数函数

    因为静态成员函数属于静态全局区,线程可以共享这个区域,故可以各自调用。

        #include <iostream>      #include <pthread.h>            using namespace std;            #define NUM_THREADS 5            class Hello      {      public:          //多线程调用,声明为static        static void* say_hello( void* args )          {              cout << "hello..." << endl;          }      };            int main()      {          pthread_t tids[NUM_THREADS];          forint i = 0; i < NUM_THREADS; ++i )          {              int ret = pthread_create( &tids[i], NULL, Hello::say_hello, NULL );              if( ret != 0 )              {                  cout << "pthread_create error:error_code" << ret << endl;              }          }          pthread_exit( NULL );      }  

    测试结果:

        hello...      hello...      hello...      hello...      hello... 
    1. 代码中如果没有pthread_join主线程会很快结束从而使整个进程结束,从而使创建的线程没有机会开始执行就结束了。加入pthread_join后,主线程会一直等待直到等待的线程结束自己才结束,使创建的线程有机会执行。

    2. 线程创建时属性参数的设置pthread_attr_t及join功能的使用
      线程的属性由结构体pthread_attr_t进行管理。

    typedef struct{    int      detachstate;       //线程的分离状态    int      schedpolicy;       //线程调度策略    struct sched_param   schedparam;   //线程的调度参数    int inheritsched;       //线程的继承性     int scope;              //线程的作用域     size_t guardsize;   //线程栈末尾的警戒缓冲区大小     int stackaddr_set;     void * stackaddr;   //线程栈的位置     size_t stacksize;   // 线程栈的大小}pthread_attr_t;

    示例:

        #include <iostream>      #include <pthread.h>            using namespace std;            #define NUM_THREADS 5            void* say_hello( void* args )      {          cout << "hello in thread " << *(( int * )args) << endl;          int status = 10 + *(( int * )args); //线程退出时添加退出的信息,status供主程序提取该线程的结束信息          pthread_exit( ( void* )status );       }            int main()      {          pthread_t tids[NUM_THREADS];          int indexes[NUM_THREADS];                    pthread_attr_t attr; //线程属性结构体,创建线程时加入的参数          pthread_attr_init( &attr ); //初始化          pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数,这个参数表明这个线程是可以join连接的,join功能表示主程序可以等线程结束后再去做某事,实现了主程序和线程同步功能          forint i = 0; i < NUM_THREADS; ++i )          {              indexes[i] = i;              int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) );              if( ret != 0 )              {              cout << "pthread_create error:error_code=" << ret << endl;          }          }           pthread_attr_destroy( &attr ); //释放内存           void *status;          forint i = 0; i < NUM_THREADS; ++i )          {          int ret = pthread_join( tids[i], &status ); //主程序join每个线程后取得每个线程的退出信息status          if( ret != 0 )          {              cout << "pthread_join error:error_code=" << ret << endl;          }          else          {              cout << "pthread_join get status:" << (long)status << endl;          }          }      }  

    测试结果:

    hello in thread hello in thread 1hello in thread 3hello in thread 40hello in thread 2pthread_join get status:10pthread_join get status:11pthread_join get status:12pthread_join get status:13pthread_join get status:14
    展开全文
  • C++ 多线程

    千次阅读 2018-01-12 09:36:58
    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下,两种类型的多任务处理:基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是...

    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下,两种类型的多任务处理:基于进程基于线程

    • 基于进程的多任务处理是程序的并发执行。
    • 基于线程的多任务处理是同一程序的片段的并发执行。

    多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程,每个线程定义了一个单独的执行路径。

    本教程假设您使用的是 Linux 操作系统,我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用,比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

    创建线程

    下面的程序,我们可以用它来创建一个 POSIX 线程:

    #include <pthread.h>
    pthread_create (thread, attr, start_routine, arg) 

    在这里,pthread_create 创建一个新的线程,并让它可执行。下面是关于参数的说明:

    参数 描述
    thread 指向线程标识符指针。
    attr 一个不透明的属性对象,可以被用来设置线程属性。您可以指定线程属性对象,也可以使用默认值 NULL。
    start_routine 线程运行函数起始地址,一旦线程被创建就会执行。
    arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数,则使用 NULL。


    创建线程成功时,函数返回 0,若返回值不为 0 则说明创建线程失败。

    终止线程

    使用下面的程序,我们可以用它来终止一个 POSIX 线程:

    #include <pthread.h>
    pthread_exit (status) 

    在这里,pthread_exit 用于显式地退出一个线程。通常情况下,pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。

    如果 main() 是在它所创建的线程之前结束,并通过 pthread_exit() 退出,那么其他线程将继续执行。否则,它们将在 main() 结束时自动被终止。

    **实例88

    以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程,每个线程输出”Hello Runoob!”:

    #include <iostream>
    // 必须的头文件
    #include <pthread.h>
    
    using namespace std;
    
    #define NUM_THREADS 5
    
    // 线程的运行函数
    void* say_hello(void* args)
    {
        cout << "Hello Runoob!" << endl;
        return 0;
    }
    
    int main()
    {
        // 定义线程的 id 变量,多个变量使用数组
        pthread_t tids[NUM_THREADS];
        for(int i = 0; i < NUM_THREADS; ++i)
        {
            //参数依次是:创建的线程id,线程参数,调用的函数,传入的函数参数
            int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
            if (ret != 0)
            {
               cout << "pthread_create error: error_code=" << ret << endl;
            }
        }
        //等各个线程退出后,进程才结束,否则进程强制结束了,线程可能还没反应过来;
        pthread_exit(NULL);
    }

    使用 -lpthread 库编译下面的程序:

    $ g++ test.cpp -lpthread -o test.o

    现在,执行程序,将产生下列结果:

    $ ./test.o
    Hello RunoobHello RunoobHello RunoobHello RunoobHello Runoob

    以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程,并接收传入的参数。每个线程打印一个 “Hello Runoob!” 消息,并输出接收的参数,然后调用 pthread_exit() 终止线程。

    //文件名:test.cpp
    
    #include <iostream>
    #include <cstdlib>
    #include <pthread.h>
    
    using namespace std;
    
    #define NUM_THREADS     5
    
    void *PrintHello(void *threadid)
    {  
       // 对传入的参数进行强制类型转换,由无类型指针变为整形数指针,然后再读取
       int tid = *((int*)threadid);
       cout << "Hello Runoob! 线程 ID, " << tid << endl;
       pthread_exit(NULL);
    }
    
    int main ()
    {
       pthread_t threads[NUM_THREADS];
       int indexes[NUM_THREADS];// 用数组来保存i的值
       int rc;
       int i;
       for( i=0; i < NUM_THREADS; i++ ){      
          cout << "main() : 创建线程, " << i << endl;
          indexes[i] = i; //先保存i的值
          // 传入的时候必须强制转换为void* 类型,即无类型指针        
          rc = pthread_create(&threads[i], NULL, 
                              PrintHello, (void *)&(indexes[i]));
          if (rc){
             cout << "Error:无法创建线程," << rc << endl;
             exit(-1);
          }
       }
       pthread_exit(NULL);
    }

    现在编译并执行程序,将产生下列结果:

    $ g++ test.cpp -lpthread -o test.o
    $ ./test.o
    main() : 创建线程, 0
    main() : 创建线程, 1
    main() : 创建线程, 2
    main() : 创建线程, 3
    main() : 创建线程, 4
    Hello Runoob! 线程 ID, 4
    Hello Runoob! 线程 ID, 3
    Hello Runoob! 线程 ID, 2
    Hello Runoob! 线程 ID, 1
    Hello Runoob! 线程 ID, 0

    向线程传递参数

    这个实例演示了如何通过结构传递多个参数。您可以在线程回调中传递任意的数据类型,因为它指向 void,如下面的实例所示:

    #include <iostream>
    #include <cstdlib>
    #include <pthread.h>
    
    using namespace std;
    
    #define NUM_THREADS     5
    
    struct thread_data{
       int  thread_id;
       char *message;
    };
    
    void *PrintHello(void *threadarg)
    {
       struct thread_data *my_data;
    
       my_data = (struct thread_data *) threadarg;
    
       cout << "Thread ID : " << my_data->thread_id ;
       cout << " Message : " << my_data->message << endl;
    
       pthread_exit(NULL);
    }
    
    int main ()
    {
       pthread_t threads[NUM_THREADS];
       struct thread_data td[NUM_THREADS];
       int rc;
       int i;
    
       for( i=0; i < NUM_THREADS; i++ ){
          cout <<"main() : creating thread, " << i << endl;
          td[i].thread_id = i;
          td[i].message = (char*)"This is message";
          rc = pthread_create(&threads[i], NULL,
                              PrintHello, (void *)&td[i]);
          if (rc){
             cout << "Error:unable to create thread," << rc << endl;
             exit(-1);
          }
       }
       pthread_exit(NULL);
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    $ g++ -Wno-write-strings test.cpp -lpthread -o test.o
    $ ./test.o
    main() : creating thread, 0
    main() : creating thread, 1
    Thread ID : 0 Message : This is message
    main() : creating thread, Thread ID : 21
     Message : This is message
    main() : creating thread, 3
    Thread ID : 2 Message : This is message
    main() : creating thread, 4
    Thread ID : 3 Message : This is message
    Thread ID : 4 Message : This is message

    连接和分离线程

    我们可以使用以下两个函数来连接或分离线程:

    pthread_join (threadid, status) 
    pthread_detach (threadid) 

    pthread_join() 子程序阻碍调用程序,直到指定的 threadid 线程终止为止。当创建一个线程时,它的某个属性会定义它是否是可连接的(joinable)或可分离的(detached)。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的,则它永远也不能被连接。

    这个实例演示了如何使用 pthread_join() 函数来等待线程的完成。

    #include <iostream>
    #include <cstdlib>
    #include <pthread.h>
    #include <unistd.h>
    
    using namespace std;
    
    #define NUM_THREADS     5
    
    void *wait(void *t)
    {
       int i;
       long tid;
    
       tid = (long)t;
    
       sleep(1);
       cout << "Sleeping in thread " << endl;
       cout << "Thread with id : " << tid << "  ...exiting " << endl;
       pthread_exit(NULL);
    }
    
    int main ()
    {
       int rc;
       int i;
       pthread_t threads[NUM_THREADS];
       pthread_attr_t attr;
       void *status;
    
       // 初始化并设置线程为可连接的(joinable)
       pthread_attr_init(&attr);
       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    
       for( i=0; i < NUM_THREADS; i++ ){
          cout << "main() : creating thread, " << i << endl;
          rc = pthread_create(&threads[i], NULL, wait, (void *)&i );
          if (rc){
             cout << "Error:unable to create thread," << rc << endl;
             exit(-1);
          }
       }
    
       // 删除属性,并等待其他线程
       pthread_attr_destroy(&attr);
       for( i=0; i < NUM_THREADS; i++ ){
          rc = pthread_join(threads[i], &status);
          if (rc){
             cout << "Error:unable to join," << rc << endl;
             exit(-1);
          }
          cout << "Main: completed thread id :" << i ;
          cout << "  exiting with status :" << status << endl;
       }
    
       cout << "Main: program exiting." << endl;
       pthread_exit(NULL);
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    main() : creating thread, 0
    main() : creating thread, 1
    main() : creating thread, 2
    main() : creating thread, 3
    main() : creating thread, 4
    Sleeping in thread 
    Thread with id : 4  ...exiting 
    Sleeping in thread 
    Thread with id : 3  ...exiting 
    Sleeping in thread 
    Thread with id : 2  ...exiting 
    Sleeping in thread 
    Thread with id : 1  ...exiting 
    Sleeping in thread 
    Thread with id : 0  ...exiting 
    Main: completed thread id :0  exiting with status :0
    Main: completed thread id :1  exiting with status :0
    Main: completed thread id :2  exiting with status :0
    Main: completed thread id :3  exiting with status :0
    Main: completed thread id :4  exiting with status :0
    Main: program exiting.
    展开全文
  • 经典C++多线程《C++ concurrency in action 》中文版书籍,经典C++多线程《C++ concurrency in action 》中文版书籍,经典C++多线程《C++ concurrency in action 》中文版书籍,经典C++多线程《C++ concurrency in ...
  • C++多线程学习

    千次阅读 2020-09-25 09:20:03
    先是一名搬运工,搬运C++多线程学习的文章,再好好学习,天天向上。 先是一个大佬博主的文章:关于C++进阶的,写得很是详细,膜拜啊! C++进阶主题 其次,是该博主多线程的具体文章 C++多线程(一)thread类 c++ 多...

    先是一名搬运工,搬运C++多线程学习的文章,再好好学习,天天向上。

    先是一个大佬博主的文章:关于C++进阶的,写得很是详细,膜拜啊!

    C++进阶主题

    其次,是该博主多线程的具体文章

    C++多线程(一)thread类

    c++ 多线线程(二)-mutex

    c++ 11 多线线程 future

    接着是另一个博主写的多线程的文章,比较通俗易懂,大家懂得~
    C++多线程类Thread(C++11)

    展开全文
  • c++ 多线程

    千次阅读 2011-03-15 16:21:00
    //这是2个线程模拟卖火车票的小程序 #include #include DWORD WINAPI Fun1Proc(LPVOID lpParameter);//thread data DWORD WINAPI Fun2Proc(LPVOID lpParameter);//thread data int index=0; int ...

    展开全文
  • C++多线程Demo

    千次阅读 2020-07-02 11:44:06
    C++多线程Demo》   多线程访问共享资源时,采取对资源加锁的方式来防止产生脏数据和错误。多线程访问同一个数据库时,数据库是共享资源,所以对库操作要加锁。对于操作同一个数据结构对象的时候也是一样的。 ...
  • C++多线程创建

    千次阅读 2018-06-03 21:06:47
    C++多线程创建
  • C++多线程类Thread(C++11)

    万次阅读 多人点赞 2018-05-04 18:59:39
    C++多线程类Thread(C++11)C++11中std命名空间将Boost库中的Thread加入,Boost的多线程从准标准变为标准,在深度学习以及应用程序开发中经常用到多线程,这里将其用法整理复习,以demo的形式复习,每次遇到问题或者...
  • C++多线程编程视频教程(C++11多线程并发) 黄强老师,国家软件设计师,...
  • 树莓派C++多线程

    千次阅读 2019-06-26 08:53:36
    树莓派中使用C++多线程执行程序1. 多线程基础知识2. 开未知数量的多线程并行处理3. 注意事项 本文记录了自己使用C++在树莓派中编写多线程程序加快运行代码运行速度。 1. 多线程基础知识 参考了相关书籍与网站:...
  • C++多线程矩阵相乘

    千次阅读 2019-03-16 14:21:02
    C++多线程demo
  • 线程与进程相比,它是一种花销小,...多编程并发在企业中开发显得尤为重要,本课程包含Windows多线程编程与C++11高并发编程,通过浅显易懂的代码与讲解,让你的多线程编程能力得到质的飞跃,具备开发高并发代码的能力!
  • C++ 多线程之创建多线程CreateThread

    千次阅读 2016-08-25 17:18:10
    一、为什么要写这篇博客一直对C++多线程一知半解,感觉没有实际进入过C++多线程的世界,因此想从头开始慢慢真正进入C++多线程,真正了解多线程。因为我也想了解Linux下的C++ 编程,因此我也会在Linux平台下进行编写...
  • C++多线程及线程锁创建
  • 一文搞定c++多线程

    2020-09-07 23:59:58
    一文搞定c++多线程 c++11引入了用于多线程操作的thread类,该库移植性更高,并且使得写多线程变得简洁了一些。 多线程头文件支持 为了支持多线程操作,c++11新标准引入了一些头文件来支持多线程编程: <thread&...
  • c++多线程实例1

    热门讨论 2012-04-08 21:40:34
    c++多线程实例1;相应博客说明地址为:http://blog.csdn.net/richerg85/article/details/7438314
  • C++多线程与共享指针

    2020-06-21 21:56:58
    文章目录C++多线程与共享指针一、C++多线程使用2.1 thread2.2 pthread C++多线程与共享指针 一、C++多线程使用 2.1 thread <thread> 该头文件包含有std::thread类与std::this_thread类。以及管理线程的函数。...
  • 目录走进线程多进程编程和多线程编程从hello world开始 走进线程 最近狂喊的 AMD YES,就是一个极强的线程撕裂者。推出的移动端CPU都已经达到了8核16线程,但是很多应用对多线程优化不好,导致多核性能更强的AMD在有...
  • C++多线程编程(真实入门!)

    万次阅读 多人点赞 2019-04-23 18:24:35
    5分钟学会简单的C++多线程编程前言线程教程创建一个线程:CreateThread()创建一个带参线程:利用lpParameter参数等待指定线程结束。 前言 本篇博客使用的库:<windows.h> 提供的线程api(当然是使用操作系统...
  • 由于最近在学习C++从底层(指针,对象模型,内存管理)再到网络socket编程,多...1. 多线程基础 这个可以看我的博客,里面都有详细的介绍以及如何使用linux C++多线程编程,参考如下: Linux C++ 多线程编程基础(汇...
  • C++多线程和QT多线程(一)

    千次阅读 2019-01-08 19:49:28
    因为工程需要处理大量的图片,这段时间看了一下C++多线程的相关内容,并参照网上写的多线程类,运用到自己的工程中。 一 多线程 https://blog.csdn.net/invincibleFF/article/details/80048868 这篇文章介绍的很...
  • C++多线程并行计算

    千次阅读 2020-03-11 16:41:49
    C++多线程并行计算多线程(std::thread) 多线程(std::thread) 写了一个简短的并行计算例子 存粹的利用CPU性能计算素数个数 //实现标准库头文件<numeric>中accumulate函数的并行版本 #include <iostream> ...
  • C++多线程编程实战 姜佑译.pdf

    千次下载 热门讨论 2017-02-18 10:07:53
    C++多线程编程实战 姜佑译.pdf
  • C++多线程编程

    万次阅读 多人点赞 2018-06-26 12:44:31
    C++ 11发布之前,C++并没有对多线程编程的专门支持,C++ 11通过标准库引入了对多线程的支持,大大方便了程序员的工作,本篇我们对这部分进行简要的介绍。需要说明的是,C++ 11标准库内部包裹了pthread库,因此,编译...
  • C++多线程编程入门

    千次阅读 2017-10-25 10:51:49
    C++多线程编程入门 前言:一直想抽个时间学习下多线程编程,今天就从C++简单多线程编程入手吧,使用Windows下的API. 1、线程创建 创建和关闭线程的API函数:HANDLE CreateThread( ...
  • C++面向对象多线程编程》推荐:毫无疑问,这是我见过的最好的、最全面的多线程方面的图书。如果你把自己看作一位程序员,而不是组件装配员,那你就需要了解多线程方面的知识。只要不是刚刚入门的C++程序员都可以从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,300
精华内容 8,120
关键字:

c++多线程

c++ 订阅