Linux C++ 多线程编程实例

Linux系统下的多线程遵循POSIX线程接口，称为 pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone()来实现的。clone()是 Linux所特有的系统调用，它的使用方式类似fork。

1、线程创建

pthread_create

int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg);

restrict 修饰的指针： 由 restrict 修饰的指针是最初唯一对指针所指向的对象进行存取的方法，仅当第二个指针基于第一个时，才能对对象进行存取。对对象的存取都限定于基于由 restrict 修饰的指针表达式中。 由 restrict 修饰的指针主要用于函数形参，或指向由 malloc() 分配的内存空间。restrict 数据类型不改变程序的语义。 编译器能通过作出 restrict 修饰的指针是存取对象的唯一方法的假设，更好地优化某些类型的例程。

返回值：若是成功建立线程返回0,否则返回错误的编号
形式参数：
pthread_t *restrict tidp 要创建的线程的线程id指针
const pthread_attr_t restrict attr 创建线程时的线程属性
void (start_rtn)(void) 返回值是void类型的指针函数
void *restrict arg start_rtn的行参

创建一个简单线程

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

void * thread1(void*)
{
    for(int i=0; i<10; i++)
    {
        cout << "thread1"<< endl;
        sleep(1);
    }
}

void * thread2(void*)
{
    for(int i=0; i<10; i++)
    {
        cout << "thread2" << endl;
        sleep(1);
    }
}

int main(int argc, char * argv[])
{
    int ret = 0;
    pthread_t id1, id2;

    ret = pthread_create(&id1, NULL, thread1, NULL);
    if(ret)
    {
        cout << "create thread1 failed ret:" << ret << endl;
    }

    ret = pthread_create(&id2, NULL, thread2, NULL);
    if(ret)
    {
        cout << "create thread2 failed ret"<< ret << endl;
    }

    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

    cout << "end" << endl;

    return 0;
}

执行结果两个线程交替执行

[admin@admin pthread]$ ./a.out 
thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2
end

向线程传递参数整形和结构体

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

struct ThreadParam
{
    int data;
    char *str;
};

void * thread1(void * arg)
{
    int * data;
    data = (int *)arg;
    cout << "data:"<< *data << endl;

    return (void*)0;
}

void * thread2(void * arg)
{
    ThreadParam* param;
    param = (ThreadParam*)arg;
    cout << "data:" << param->data << " str:" << param->str << endl;

    return (void*)0;
}

int main(int argc, char * argv[])
{
    int ret = 0;

    pthread_t id1;
    pthread_t id2;

    int test = 4;
    int *attr = &test;


    ThreadParam param;
    param.data = 1;
    param.str = "abcd";

    ret = pthread_create(&id1, NULL, thread1, (void*)attr);

    if(ret)
    {
        cout << "create thread1 failded ret:" << ret << endl;
    }

    ret = pthread_create(&id2, NULL, thread2, (void*)&param);

    if(ret)
    {
        cout << "create thread2 failded ret:" << ret << endl;
    }

    pthread_join(id1, NULL);
    pthread_join(id2, NULL);
}

执行结果

[admin@admin pthread]$ ./a.out 
data:4
data:1 str:abcd

2、线程的终止

如果进程中任何一个线程中调用exit，_Exit,或者是_exit，那么整个进程就会终止，
与此类似，如果信号的默认的动作是终止进程，那么，把该信号发送到线程会终止进程。
线程的正常退出的方式：
(1) 线程只是从启动例程中返回，返回值是线程中的退出码
(2) 线程可以被另一个进程进行终止
(3) 线程自己调用pthread_exit函数

两个重要的函数原型：

pthread_exit

void pthread_exit(void *rval_ptr);
/rval_ptr 线程退出返回的指针/

pthread_join

int pthread_join(pthread_t thread,void **rval_ptr);
/成功结束进程为0,否则为错误编码/

pthread_join使一个线程等待另一个线程结束。
代码中如果没有pthread_join主线程会很快结束从而使整个进程结束，从而使创建的线程没有机会开始执行就结束了。加入pthread_join后，主线程会一直等待直到等待的线程结束自己才结束，使创建的线程有机会执行。
头文件 ： #include <pthread.h>
函数定义： int pthread_join(pthread_t thread, void **retval);
描述 ：pthread_join()函数，以阻塞的方式等待thread指定的线程结束。当函数返回时，被等待线程的资源被收回。如果线程已经结束，那么该函数会立即返回。并且thread指定的线程必须是joinable的。
参数 ：thread: 线程标识符，即线程ID，标识唯一线程。retval: 用户定义的指针，用来存储被等待线程的返回值。
返回值 ： 0代表成功。 失败，返回的则是错误号。

线程正常退出

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

void * thread(void * arg)
{
    for(int i=0; i<10; i++)
    {
        cout <<"thread i:"<< i << endl;

        if(i==5)
        {
            pthread_exit(0);
        }

        sleep(1);
    }
}

int main(int argc, char * argv[])
{
    int ret = 0;
    
    pthread_t id1;

    ret = pthread_create(&id1, NULL, thread, NULL);

    if(ret)
    {
        cout << "create thread failed" << endl;
    }

    pthread_join(id1, NULL);

    cout << "end" << endl;
}

执行结果

[admin@admin pthread]$ ./a.out 
thread i:0
thread i:1
thread i:2
thread i:3
thread i:4
thread i:5
end

线程结束并返回一个复杂的数据结构

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

struct TheadParam
{
    int data;
    char *str;
};

void * thread(void * arg)
{
    TheadParam * param = new TheadParam;
    param->data = 1;
    param->str = "abcd";

    return (void*)param;
}

int main(int argc, char * argv[])
{
    int ret = 0;

    pthread_t id1;

    void *p;

    TheadParam* param;

    ret = pthread_create(&id1, NULL, thread, NULL);

    if(ret)
    {
        cout << "create thread failed ret:" << ret << endl;
    }

    pthread_join(id1, &p);

    param = (TheadParam*)p;

    delete p;

    cout << "data:" << param->data << " str:" << param->str << endl;
}

执行结果

[admin@admin pthread]$ ./a.out 
data:0 str:abcd

3、线程标识
函数原型：

pthread_self

pthread_t pthread_self(void);
获得线程自身的ID

getpid

pid_t getpid(void);
取得进程识别码

#include<iostream>
#include<pthread.h>
#include<unistd.h>

using namespace std;

void * thread(void * arg)
{
    pthread_t tid = pthread_self();

    cout << "tid:" << tid << endl;

    sleep(1);

    return (void*)0;
}

int main(int argc, char * argv[])
{
    int ret = 0;

    pthread_t id1;

    ret = pthread_create(&id1, NULL, thread, NULL);

    if(ret)
    {
        cout << "create thread failed ret:" << ret << endl;
    }

    pthread_join(id1, NULL);

    pthread_t tid = pthread_self();
    pid_t pid = getpid();

    cout << "tid:" << tid << " pid:" << pid << endl;
}

执行结果

[admin@admin pthread]$ ./a.out 
tid:140010420446976
tid:140010437293888 pid:8953

后面的文章介绍线程同步的四种方式