Linux-线程

进程 与 线程:

参考自： Linux多线程编程初探 - 峰子_仰望阳光 - 博客园 (cnblogs.com)

进程:
　　典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。
有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。　　

　　进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。
在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。
程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。// 程序是静态概念，进程是动态概念
 

线程:
    线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。

二者联系:
　进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。
线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。

二者区别:
  总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）

使用线程理由:
　1.和进程相比，它是一种非常 "节俭" 的多任务操作方式。省内存，切换效率高
    2.线程间方便的通信机制 // 共享数据，方便线程间的通信 --（同一进程内的线程共享进程的地址空间）

"进程——资源分配的最小单位，线程——程序执行的最小单位"  

Linux线程开发API:

多线程开发的最基本概念主要包含三点：线程，互斥锁，条件  3 + 4 + 5

线程操作又分线程的创建，退出，等待 3 种

互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。

条件操作有 5 种操作：创建，销毁，触发，广播和等待。

线程:

1. 线程创建

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

// 返回：若成功返回0，否则返回错误编号

　2. 线程退出

　　单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：

　　1）线程只是从启动例程中返回，返回值是线程的退出码。

　　2）线程可以被同一进程中的其他线程取消。

　　3）线程调用pthread_exit：

#include <pthread.h>
int pthread_exit(void *rval_ptr);

3. 线程等待

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
pthread_t pthread_self(void);
// 返回：调用线程的ID

case1：while来等待

#include <pthread.h>
#include <stdio.h>

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

void *func1(void *arg)
{//获取当前线程ID
    printf("thread1: %ld pthread create.\n",(unsigned long)pthread_self());
    printf("thread1: param is %d\n",*((int *)arg));
}

int main()
{
    pthread_t thread1;
    int arg = 100;
    int pret;

 //创建线程1-thread1，调用函数func1，传递参数arg，NULL 创建默认属性打的线程
    pret = pthread_create(&thread1, NULL, func1, (void *)(&arg));
    if(!pret){//进程创建成功返回0
    puts("create success.");
    }
    else {//失败返回-1
        puts("create failed.");
    }
   printf("main: %ld .\n",(unsigned long)pthread_self());// 获取main函数的线程ID
    while(1); // 不加的话，主线程会没创建完线程就退出

    return 0;
}
========================================
 

case2:结合等待退出的API来调用:

#include <pthread.h>
#include <stdio.h>

// int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
// int pthread_exit(void *rval_ptr);
// int pthread_join(pthread_t thread, void **rval_ptr);
void *func1(void *arg)
{
    //static int pret=88; //static 保护pret退出这个函数不被销毁
     static char * p="this is run out."; // 返回字符串
    printf("thread1: %ld pthread create.\n",(unsigned long)pthread_self());
    printf("thread1: param is %d\n",*((int *)arg));
   // pthread_exit((void*)&pret);
// 线程退出 -- 里面的参数 -- 线程退出状态 -- 自己设计，可以是int 也可以是char*
 pthread_exit((void*)p); // 返回字符串
}

int main()
{
    pthread_t thread1;
   // int* pthr=NULL;
 char* pthr=NULL;  // 接收返回的字符串
    int arg = 100;
    int pret;
    pret = pthread_create(&thread1, NULL, func1, (void *)(&arg)); //arg --参数传递
    if(!pret){
    puts("create success.");
    
    }
    else {
        puts("create failed.");
    }
   printf("main: %ld .\n",(unsigned long)pthread_self());
    // 等待线程thread1退出(线程没退出phread_exit就会阻塞)，第二个参数收回线程的退出

  状态，NULL--不收回
    pthread_join(thread1,(void**)&pthr); // 指针再取地址达到二级指针类型才能强制装换位二级指针
    //printf("thread quit id:%d\n",*pthr);// 查看指针拿到的退出数据
   printf("thread quit id:%s\n",pthr);// 输出进程退出返回值，字符串名就是指针
    return 0;
}
========================================
 

case3: 线程共享内存验证:

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

// int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data=0;// 共享变量
void *func1(void *arg)
{
    printf("thread1: %ld pthread create.\n", (unsigned long)pthread_self());
    printf("thread1: param is %d\n", *((int *)arg));
    while(1){
        printf("thread1:  %d\n",g_data++);
        sleep(1);
    }
  //  pthread_exit(NULL);
}
void *func2(void *arg)
{
    printf("thread2: %ld pthread create.\n", (unsigned long)pthread_self());
    printf("thread2: param is %d\n", *((int *)arg));
     while(1){
        printf("thread2:  %d\n",g_data++);
        sleep(1);
    }
   // pthread_exit(NULL);
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    int arg = 100;
    int pret;
    pret = pthread_create(&thread1, NULL, func1, (void *)(&arg));
    if (!pret)
    {
        puts("main:create thread1 success.");
    }
    else
    {
        puts("main:create  thread1 failed.");
    }

    pret = pthread_create(&thread2, NULL, func2, (void *)(&arg));
    if (!pret)
    {
        puts("main:create thread2 success.");
    }
    else
    {
        puts("main:create thread2 failed.");
    }
     while(1){
        printf("main:  %d\n",g_data++);
        sleep(1);
    }
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    printf("main: %ld .\n", (unsigned long)pthread_self());
;

    return 0;
}
==============================

输出结果中，我们发现在func1，func2，main函数三个线程中，g_data的数据时不重样且递增的，什么我们的线程共享了进程分配到的内存

 

互斥锁API的使用:

概念:
　互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁

1. 创建及销毁互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号
　要用默认的属性初始化互斥量，只需把attr设置为NULL。

2. 加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_trylock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号

 上锁后，只有在锁里面的代码执行完后才解锁，解锁前不会去调用其他进程
互斥量就是一把锁，对锁有上锁和解锁操作，这两个操作之间的代码叫共享资源，没执行完共享资源进程前，
其他进程不能调用，执行完后，其他进程可以去争抢这把锁，第一个争抢到的进程又能上锁，解锁， 这样就保证了
我们的进程是一个线程一个线程的执行，在没有执行完单曲线程之前不会去执行其他线程

case1: 互斥锁应用

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

// int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data=0;// 共享变量
pthread_mutex_t mutex;
void *func1(void *arg)
{
    int i;

    // 上锁 -- 然后后续想要再上这把锁mutex 就会被阻塞，直到这把锁被解锁，保证了上锁解锁里面的函数快能执行完，才去执行其他进程，保证进程执行的时候不受打扰
    pthread_mutex_lock(&mutex);
    for(i=0;i<3;++i)
    {
    printf("thread1: %ld pthread create.\n", (unsigned long)pthread_self());
    printf("thread1: param is %d\n", *((int *)arg));
    sleep(1);
    }

//解锁
    pthread_mutex_unlock(&mutex);
  //  pthread_exit(NULL);
}
void *func2(void *arg)
{
    pthread_mutex_lock(&mutex); // 进程1没开锁你上不了锁，阻塞在这里
    printf("thread2: %ld pthread create.\n", (unsigned long)pthread_self());
    printf("thread2: param is %d\n", *((int *)arg));
    pthread_mutex_unlock(&mutex);
   // pthread_exit(NULL);
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    int arg = 100;
    int pret;
    //int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
    // 初始化我们的互斥

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/423834