线程的相关概念，线程与进程的区别，如何进行多线程编程以及如何使用互斥锁

痛定思痛。 2023-07-05 10:12 2阅读 0赞

在前面的文章中说了，进程是运行起来的程序，而线程就可以理解为实现进程功能的具体单位，是进程执行的最小单位。  
我们可以这杨理解：进程是资源分配的最小单位，线程是资源调度的最小单位。  
**线程和进程的联系：**  
1、一个进程至少有一个线程，一个线程只属于一个进程。  
2、同一个进程的多个线程共享数据空间代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储），但每条线程拥有自己的堆栈和局部变量，用于存放所有的临时变量和局部变量。

**linux下的多线程编程**  
前面我们有了多进程编程，那么为什么还需要多线程编程呢？  
**因为多线程编程相比于多进程有更多的优点：**  
1、和进程相比，它是一种非常节俭的多任务操作方式。在Linux系统下，启动一个新的进程必须给它分配一个地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段。而使用运行于一个进程的多个线程，它们之间使用相同的地址空间，而且线程间彼此切换所需的时间也远小于进程间切换所需要的时间。  
2、线程间的通讯更为方便。对于不同的进程，它们有独立的数据空间，要进行数据的传递只能通过进程间通讯的方式进行。而在同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用。  
3、使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。  
4、改善程序结构。一个复杂的进程可以分为多个线程，成为几个独立或半独立的运行部分，这样程序会利于理解和修改。

**创建线程**  
\#include <pthread.h>  
int pthread\_creat(pthread\_t \*tidp,const pthread\_attr\_t \*attr, void \*(\*start\_rtn)(void),void \*arg)  
tidp: 线程ID  
attr: 线程属性（通常为空）  
start\_rtn: 线程要执行的函数  
arg: start\_rtn的参数

**线程等待**  
\#include <pthread.h>  
int pthread\_join(pthread\_t tid,void \*\*rval\_ptr)  
功能：阻塞调用线程，直到指定的线程终止。  
tid: 等待推出的线程ID  
rval\_ptr: 线程退出的返回值的指针

**线程退出**  
\#include <pthread.h>  
void pthread\_exit(void \*rval\_ptr)  
功能：终止调用线程  
rval\_ptr：线程退出返回值的指针

1 #include <stdio.h>
      2 #include <pthread.h>
      3 #include <unistd.h>
      4 
      5 void *func(void *args)
      6 {
        
      7     printf("this is new preath\n");
      8     return NULL;
      9 }
     10 
     11 
     12 int main(int argc, char **argv)
     13 {
        
     14     pthread_t th;
     15     pthread_create(&th,NULL,func,NULL);
     16     pthread_join(th,NULL);
     17     pthread_exit(NULL);
     18     
     19     return 0;
     20 }

**互斥锁的使用**  
在使用互斥锁之前我们先看一段代码

1 #include <stdio.h>
      2 #include <pthread.h>
      3 #include <unistd.h>
      4 
      5 int s = 0;
      6 
      7 void *func(void *args)
      8 {
        
      9     int i;
     10     for (i=0;i<1000000;i++) {
        
     11         s++;
     12     }
     13     return NULL;
     14 }
     15 
     16 
     17 int main(int argc, char **argv)
     18 {
        
     19     pthread_t th;
     20     pthread_t th2;
     21     pthread_create(&th,NULL,func,NULL);
     22     pthread_create(&th2,NULL,func,NULL);
     23     pthread_join(th,NULL);
     24     pthread_join(th2,NULL);
     25 
     26     printf("s = %d\n",s);
     27 
     28     pthread_exit(NULL);
     29 
     30     return 0;
     31 }

**最终的结果s应该等于两百万，但实际运行的结果是**

![在这里插入图片描述][20200213195356273.png]  
可以看到，最终s的值是远远不够两百万的。那为什么会出现这种情况呢？  
这是因为这两个线程是交叉着运行的，当一个线程运行的时候，它就会去取s的值，然后加1，再将s的值返回内存，这个过程就存在着问题。  
**当th线程从内存中取出s时，这时s的值为0，在th还没有将结果返回内存时，th2也去读了s，这时的s的值就还是为0，不是为1，所以在两条线程运行的过程中就发生了很多次这种情况，因此最终结果就远小于两百万。**  
因此我们要保证，一条线程完整的进行一次操作后才让另一条线程运行，这时就需要我们的互斥锁了。  
互斥锁锁的不是变量，而是一段代码。  
在加上互斥锁之后，这段代码在同一时刻就只能让一个线程使用。

实际使用

1 #include <stdio.h>
      2 #include <pthread.h>
      3 #include <unistd.h>
      4 
      5 pthread_mutex_t lock;  //创建互斥锁
      6 int s = 0;
      7 
      8 void *func(void *args)
      9 {
        
     10     int i;
     11     for (i=0;i<1000000;i++) {
        
     12         pthread_mutex_lock(&lock);  //加锁
     13         s++;
     14         pthread_mutex_unlock(&lock);  //解锁
     15     }
     16     return NULL;
     17 }
     18 
     19 
     20 int main(int argc, char **argv)
     21 {
        
     22     pthread_t th;
     23     pthread_t th2;
     24     pthread_mutex_init(&lock, NULL);  //初始化互斥锁
     25 
     26     pthread_create(&th,NULL,func,NULL);
     27     pthread_create(&th2,NULL,func,NULL);
     28     pthread_join(th,NULL);
     29     pthread_join(th2,NULL);
     30 
     31     printf("s = %d\n",s);
     32 
     33     pthread_exit(NULL);
     34 
     35     return 0;
     36 }

运行结果  
![在这里插入图片描述][20200213200859237.png]  
可以看到，现在的运行结果就是正确的了。  
在这个程序中，当两个线程都在运行时，若th先运行，则th2运行时就会发现mutex\_lock被占用了，那th2就必须等th解锁后，再用mutex\_lock.

[20200213195356273.png]: https://img-blog.csdnimg.cn/20200213195356273.png
[20200213200859237.png]: https://img-blog.csdnimg.cn/20200213200859237.png