文章目录
  1. 1. 基本概念
  2. 2. 线程函数、实例程序说明
  1. 什么是进程?
  2. 什么是线程?
  3. 进程跟线程的关系?
  4. 引进线程的优点?

overlord tank

基本概念

preemptive multitasking抢先式多任务:意思是操作系统能够强迫应用程序把CPU分享给其他人,程序员不需要额外的努力。

程序只是一组指令的有序集合,它本身没有任何运行的含义,只是一个静态实体.

进程Process是正在执行的程序实例。进程是程序在某个数据集上的执行,是一个动态实体。所以进程因创建才会产生,调度才会运行,所以进程会因等待资源或事件而被处于等待状态,一旦完成任务而被撤消,进程反映了一个程序在一定的数据集上运行的全部动态过程

逻辑上将一个进程划分为一下几段:

  • 文本:程序的指令

  • 数据:程序使用的静态变量

  • 堆:程序可以从该区域动态分配额外内存

  • 栈:随函数调用、返回而增减的一片内存,用于为局部变量和函数调用链接信息分配存储空间

thread线程:是进程的一个实体,在一个程序中的多个执行路线就叫做线程。每个线程都会执行相同的程序代码,共享统一数据区域和堆。可是每个线程都拥有自己的栈,用来状态本地变量和函数调用的链接信息. 线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。

线程之间可通过共享的全局变量进行通信。借助于线程API所提供的条件变量和互斥机制,进程所属的线程之间得以相互通信并同步行为————尤其实在对共享变量的使用方面。

线程和进程的关系是:线程是属于进程的,是CPU调度和分派的基本单位。线程运行在进程空间内,同一进程所产生的线程共享同一内存空间,当进程退出时该进程所产生的线程都会被强制退出并清除。

线程可与属于同一进程的其它线程共享进程所拥有的全部资源,但是其本身基本上不拥有系统资源,只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

所有的进程至少有一个执行线程。

多线程,使程序得以将其工作分开,独立运作,不互相影响


线程函数、实例程序说明

  • pthread_create
    pthread_create 作用是创建一个新线程;
    函数原型
    1
    2
    3
    #include<pthread.h>

    int pthread_create(pthread_t *thread,pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);

第一个参数pthread_t *thread:线程被创建时候这个指针指向的变量中将被写入一个线程号,我们用线程号来引用新的线程。

第二个参数pthread_attr_t *attr用于设置线程的属性;一般不需要设置特殊的属性,所以我们设置该参数为NULL

最后2个参数分别告诉线程将要启动执行的函数void *(*start_routine)(void *) 该函数以一个指向void的指针为参数,返回的也是一个指向void的指针。因此可以传递一个任一类型的参数并返回一个任一类型的指针。
和:传递给函数的参数void *arg

该函数调用成功时返回值是0,如果失败则返回错误代码

  • pthread_join
    prhread_join 的作用是使一个线程等待另一个线程结束。这个函数的定义如下:
    1
    2
    #include<pthread.h>
    int pthread_join(pthread_t th,void **thread_return );

第1个参数:指定了将要等待的线程,线程通过pthread_crtate返回的标识符来指定。

第2个参数:是一个指针,它指向另一个指针,而后者指向线程的返回值。与pthread_create类似,这个函数在成功时返回0,失败时返回错误代码。

在Linux中,新建的线程并不是在原先的进程中,而是系统通过一个系统调用clone()。该系统copy了一个和原先进程完全一样的进程,并在这个进程中执行线程函数。不过这个copy过程和fork不一样。 copy后的进程和原先的进程共享了所有的变量,运行环境。这样,原先进程中的变量变动在copy后的进程中便能体现出来。

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

所有线程都有一个线程号,也就是Thread ID。其类型为pthread_t。通过调用pthread_self()函数可以获得自身的线程号。

  • pthread_exit
    线程通过pthread_exit函数终止执行;这个函数的作用是,终止调用它的线程并返回一个指向对象的指针。

函数原型

1
2
#include<pthread.h>
void pthread_exit(void *retval);

  1. 简单的线程程序:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*这个程序创建了一个新线程,新线程与原先的线程共享变量,并在结束的时候向原先的线程返回一个结果*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

void *thread_function(void *arg); //需要启动的函数原型

char message[] = "Hello World";

int main() {
int res;
pthread_t a_thread; // 指向pthread_t类型数据的指针
void *thread_result;
res = pthread_create(&a_thread, NULL, thread_function, (void *)message); //创建一个新的线程;新线程从 thread_function开始执行
if (res != 0) { //如果创建失败
perror("Thread creation failed");
exit(EXIT_FAILURE); //eixt 退出,退出整个程序;
}
printf("Waiting for thread to finish...\n");
res = pthread_join(a_thread, &thread_result); //这个函数等待它所指定的线程结束后才返回。参数:&thread_result是指向线程返回的指针,也就是指向 thread_function函数内的 pthread_exit;
if (res != 0) {
perror("Thread join failed");
exit(EXIT_FAILURE);
}
printf("Thread joined, it returned %s\n", (char *)thread_result);
printf("Message is now %s\n", message); // 数组message已经被新线程修改,但主线程仍能访问
exit(EXIT_SUCCESS);
}

void *thread_function(void *arg) {
printf("thread_function is running. Argument was %s\n", (char *)arg);
sleep(3); //睡3秒
strcpy(message, "Bye!"); //更新全局变量
pthread_exit("*****Thank you for the CPU time"); //线程通过pthread_exit函数终止执行,这个函数退出并主动向 主线程 返回一个字符串;这个函数的作用是,终止调用它的线程并返回一个指向某个对象的指针。
}


/*
这个程序 一开始 用 pthread_create 创建一个线程(thread_function),如果这个线程调用成功将会有2个线程, 1个线程是main另一个线程是 thread_function函数

原先的线程在查明新线程启动后,将调用pthread_join函数;
*/

  1. 2个线程同时执行
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <pthread.h>

    void *thread_function(void *arg);
    int run_now = 1;
    char message[] = "Hello World";

    int main() {
    int res;
    pthread_t a_thread;
    void *thread_result;
    int print_count1 = 0;

    res = pthread_create(&a_thread, NULL, thread_function, (void *)message);
    if (res != 0) {
    perror("Thread creation failed");
    exit(EXIT_FAILURE);
    }

    while(print_count1++ < 20) { // 这个while循环 只输出1次 1
    if (run_now == 1) {
    printf("1");
    run_now = 2;
    }
    else {
    sleep(1);
    }
    }

    printf("\nWaiting for thread to finish...\n");
    res = pthread_join(a_thread, &thread_result);
    if (res != 0) {
    perror("Thread join failed");
    exit(EXIT_FAILURE);
    }
    printf("Thread joined %s\n", (char *)thread_result);
    exit(EXIT_SUCCESS);
    }

    void *thread_function(void *arg) {
    int print_count2 = 0;

    while(print_count2++ < 20) {
    if (run_now == 2) {
    printf("2");
    run_now = 1;
    }
    else {
    sleep(1);
    }
    }

    sleep(3);
    pthread_exit("*******EOF*****");
    }

每个线程通过设置run_now变量的方法通知另一个线程开始运行,然后,它会等待另一个线程改变了这个变量的值后再次运行。

这2个线程共享run_now变量


C++11多线程

文章目录
  1. 1. 基本概念
  2. 2. 线程函数、实例程序说明