Linux系统编程——线程

LanUU123

于 2024-07-27 11:53:36 发布

阅读量674

点赞数 13

文章标签： linux c语言

本文链接：https://blog.csdn.net/qq_61802519/article/details/140732254

版权

学习目标：

pthread 线程

学习内容：

pthread 线程

优点：比多进程节省资源，可以共享变量。

概念：线程是轻量级进程，一般是一个进程中的多个任务。
进程是系统中最小的资源分配单位.
线程是系统中最小的执行单位。

特征：
1、共享资源
2、效率高  30%
3、三方库： pthread  clone   posix
3.1 编写代码头文件： pthread.h
3.2 编译代码加载库： -lpthread   library
libpthread.so
gcc 1.c -lpthread
缺点：
1，线程和进程相比，稳定性，稍微差些
2，线程的调试gdb，相对麻烦些。

线程与进程区别：

资源：
线程比进程多了共享资源。  IPC
线程又具有部分私有资源。
进程间只有私有资源没有共享资源。
空间：
进程空间独立，不能直接通信。
线程可以共享空间，可以直接通信。

3、线程的设计框架  posix
创建多线程 ==》线程空间操作 ===》线程资源回收
errno   strerror（errno）  perror();
3.1 创建多线程：
int pthread_create(
pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
功能：该函数可以创建指定的一个线程。
参数：thread 线程id，需要实现定义并由该函数返回。
  attr   线程属性，一般是NULL，表示默认属性。
  start_routine 指向指针函数的函数指针。
   本质上是一个函数的名称即可。称为
th 回调函数,是线程的执行空间。
{
}
  arg  回调函数的参数，即参数3的指针函数参数。
返回值：成功 0
失败错误码

注意：一次pthread_create执行只能创建一个线程。
  每个进程至少有一个线程称为主线程。
  主线程退出则所有创建的子线程都退出。
  主线程必须有子线程同时运行才算多线程程序。
  线程id是线程的唯一标识，是CPU维护的一组数字。
  pstree 查看系统中多线程的对应关系。
  多个子线程可以执行同一回调函数。
ps -eLf 查看线程相关信息Low Weigth Process
ps -eLo pid,ppid,lwp,stat,comm
2、pthread_t pthread_self(void); unsigned long int; %lu
   功能：获取当前线程的线程id
   参数：无
   返回值：成功返回当前线程的线程id
    失败  -1；
syscall(SYS_gettid);
这个方法重启后失效
alias gcc='gcc -g -pthread '
unalias gcc

永久起作用
cd ~ //家目录
vim .bashrc
alias gcc='gcc -g -pthread '  :wq

source .bashrc  生效

线程的退出：
1：自行退出 ==》自杀  ==》子线程自己退出
exit(1);
void pthread_exit(void *retval);  exit  return p;
功能：子线程自行退出
参数： retval 线程退出时候的返回状态，临死遗言。
返回值：无

2：强制退出 ==》他杀  ==》主线程结束子线程
int pthread_cancel(pthread_t thread);
功能：请求结束一个线程
参数：thread 请求结束一个线程tid
返回值：成功 0
失败 -1；

线程的回收
1、线程的回收机制 ====》不同与进程没有孤儿线程和僵尸线程。
  ====》主线程结束任意生成的子线程都会结束。
  ====》子线程的结束不会影响主线程的运行。
char * retval ; retval++; 1
int * retval;
  int pthread_join(pthread_t thread, void **retval);
  功能：通过该函数可以将指定的线程资源回收，该函数具有
       阻塞等待功能，如果指定的线程没有结束，则回收线程
会阻塞。
  参数：thread  要回收的子线程tid
        retval  要回收的子线程返回值/状态。==》ptread_exit(值);
  返回值：成功 0
     失败 -1；

  子线程的回收策略：
  1、如果预估子线程可以有限范围内结束则正常用pthread_join等待回收。
  2、如果预估子线程可能休眠或者阻塞则等待一定时间后强制回收。
  3、如果子线程已知必须长时间运行则，不再回收其资源。


  线程的参数，返回值


  1、传参数

传整数 ===》int add(int a,int b);  ///a b 形参
add(x,y);    x y 实参

pthread_create(&tid,NULL,fun,x);

fun ==>void * fun(void * arg);

练习：创建一个子线程并向该线程中传入一个字符在
  线程中打印输出。
  在此基础上向子线程中传入一个字符串，并在
  子线程中打印输出。


  add(int a, int b)
  {
int c = a+b;
char buf[]=""
return c;
  }
5
  int d = add(2,3);
传字符串
栈区字符数组：
字符串常量：
char *p = "hello";
堆区字符串；
char *pc = (char *)malloc(128);
ptread_create(&tid,NULL,fun,pc);

pthread_join(tid,NULL);

free(pc);

fun(void *arg)
{
char * pc = (char *)arg ;
printf("%s \n",pc);
%c
}

传结构体
1、定义结构体类型
2、用结构体定义变量
3、向pthread_create传结构体变量
4、从fun子线程中获取结构体数据

练习：
定义一个包含不同数据类型的测试结构体
并向子线程传参数，同时在子线程中打印输出。

定义一个回调函数可以完成计算器的功能
定义一个数据结构体可以一次传入不同的数据
和计算方式并将结果打印输出。
//2 + 3.6
// 2 + 3  2+3
// 8 * 6
typedef strcut
{
float a;
float b;
char c;//+ - * /
float d;
}JSQ;

返回值：pthread_exit(0) ===>pthread_exit(9);
pthread_join(tid,NULL); ===>pthread_join(tid,?);
10;
-10;
int * p =malloc(4);
*p = -10;
1、pthread_exit(?) ==>? = void * retval;
  纯地址

2、pthread_join(tid,?) ==>? = void **retval;
地址的地址
原理：子线程退出的时候，可以返回一个内存地址
  改值所在的内存中可以存储任何数据，只要
  地址存在，则数据都可以正常返回。

地址有三种：
0、栈区变量  错误，子线程结束该地址失效。
1、全局变量  失去意义，本质可以直接访问。

2、静态变量
3、堆区变量

  主线程通过一个地址形式的变量来接受子进程
  返回的地址变量就可以将该地址中的数据取到。

练习：从子线程中申请一块堆区内存并存字符串
      将该字符串以返回值形式返回到主线程并打印输出。

作业：
从主线程中获取用户输入的信息并组织成一个结构体
变量并以函数传参数方式发给不同的子线程，子线程
拿到用户输入的数据后各个运算后以返回值形式返回
给主线程，并在主线程中分别输出。

设置分离属性，目的线程消亡，自动回收空间。
attribute
int pthread_attr_init(pthread_attr_t *attr);
功能，初始化一个attr的变量
参数：attr，需要变量来接受初始值
返回：0  成功，
非0 错误；
       int pthread_attr_destroy(pthread_attr_t *attr);
  功能：销毁attr变量。
  attr，属性变量
  返回：0  成功，
非0 错误；


man -k
int pthread_attr_setdetachstate(pthread_attr_t *attr
, int detachstate);
功能：把一个线程设置成相应的属性
参数，attr，属性变量，有init函数初始化他。
detachstate：有2个可选值，

PTHREAD_CREATE_DETACHED：设置分离属性。

第二种设置分离属性：
int pthread_deatch(pthread_t thread);
功能，设置分离属性
参数，线程id号，填自己的id

do{

}while()
void pthread_cleanup_push(void (*routine)(void *)， void *arg);

功能：注册一个线程清理函数
参数，routine，线程清理函数的入口
arg，清理函数的参数。
返回值，无

void pthread_cleanup_pop(int execute);
功能：调用清理函数
execute，非0  执行清理函数
0 ，不执行清理

返回值，无

do
{

}while(1)

process thread
fork pthread_create
getpid,ppid, pthread_self
exit, pthread_exit
wait,waitpid, pthread_join
kill, pthread_cancel
atexit pthread_clean,
exec system--->fork->exec (ls)

man pthread_mutex_init
ping www.baidu.com
sudo apt-get install manpages-posix manpages-posix-dev

vim /etc/network/interface
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

vim /etc/resolv.conf
nameserver 8.8.8.8

sudo /etc/init.d/networking restart

ifconfig
改软件源。。。
sudo apt-get update

to
线程控制：互斥与同步

概念：
互斥 ===》在多线程中对临界资源的排他性访问。

互斥机制 ===》互斥锁  ===》保证临界资源的访问控制。

pthread_mutex_t   mutex;
互斥锁类型        互斥锁变量内核对象

框架：
定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
****                      ***      ***

1、定义：
pthread_mutex_t   mutex;

2、初始化锁
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr);
功能：将已经定义好的互斥锁初始化。
参数：mutex 要初始化的互斥锁
  atrr  初始化的值，一般是NULL表示默认锁
返回值：成功 0
失败非零
3、加锁：
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：用指定的互斥锁开始加锁代码
  加锁后的代码到解锁部分的代码属于原子操作，
  在加锁期间其他进程/线程都不能操作该部分代码
  如果该函数在执行的时候，mutex已经被其他部分
  使用则代码阻塞。

参数： mutex 用来给代码加锁的互斥锁
返回值：成功 0
失败非零

4、解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：将指定的互斥锁解锁。
  解锁之后代码不再排他访问，一般加锁解锁同时出现。
参数：用来解锁的互斥锁
返回值：成功 0
失败非零

5、销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：使用互斥锁完毕后需要销毁互斥锁
参数：mutex 要销毁的互斥锁
返回值：成功  0
失败  非零

6、trylock
int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：类似加锁函数效果，唯一区别就是不阻塞。
参数：mutex 用来加锁的互斥锁
返回值：成功 0
失败非零
E_AGAIN

int a  = 0 ;

while(5000--)
{
int temp = a;
printf("%d",temp+1);
a =temp+1;
}

get win   sleep(rand()%5);
get win
get win
leave

线程的同步 ===》同步
  ===》有一定先后顺序的对资源的排他性访问。

原因：互斥锁可以控制排他访问但没有次序。

linux下的线程同步  ===》信号量机制 ===》semaphore.h   posix
sem_open();
信号量的分类：
1、无名信号量 ==》线程间通信
2、有名信号量 ==》进程间通信

框架：
信号量的定义 ===》信号量的初始化 ==》信号量的PV操作
===》信号量的销毁。

semaphore
1、信号量的定义：
   sem_t            sem;
   信号量的类型     信号量的变量

2、信号量的初始化：
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：将已经定义好的信号量赋值。
参数：sem 要初始化的信号量
  pshared = 0 ;表示线程间使用信号量
  !=0 ;表示进程间使用信号量
  value 信号量的初始值，一般无名信号量
  都是二值信号量，0 1
  0 表示红灯，进程暂停阻塞
  1 表示绿灯，进程可以通过执行
返回值：成功  0
失败  -1；
3、信号量的PV 操作
   P ===》申请资源===》申请一个二值信号量
   V ===》释放资源===》释放一个二值信号量

   P操作对应函数 ==》sem_wait();
   V操作对应函数 ==》sem_post();

int sem_wait(sem_t *sem);
功能：判断当前sem信号量是否有资源可用。
  如果sem有资源(==1)，则申请该资源，程序继续运行
  如果sem没有资源(==0)，则线程阻塞等待，一

加载更多

ifconfig
改软件源。。。
sudo apt-get update

to
线程控制：互斥与同步

概念：
互斥 ===》在多线程中对临界资源的排他性访问。

互斥机制 ===》互斥锁  ===》保证临界资源的访问控制。

pthread_mutex_t   mutex;
互斥锁类型        互斥锁变量内核对象

框架：
定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
****                      ***      ***

1、定义：
pthread_mutex_t   mutex;

2、初始化锁
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr);
功能：将已经定义好的互斥锁初始化。
参数：mutex 要初始化的互斥锁
  atrr  初始化的值，一般是NULL表示默认锁
返回值：成功 0
失败非零
3、加锁：
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：用指定的互斥锁开始加锁代码
  加锁后的代码到解锁部分的代码属于原子操作，
  在加锁期间其他进程/线程都不能操作该部分代码
  如果该函数在执行的时候，mutex已经被其他部分
  使用则代码阻塞。

参数： mutex 用来给代码加锁的互斥锁
返回值：成功 0
失败非零

4、解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：将指定的互斥锁解锁。
  解锁之后代码不再排他访问，一般加锁解锁同时出现。
参数：用来解锁的互斥锁
返回值：成功 0
失败非零

5、销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：使用互斥锁完毕后需要销毁互斥锁
参数：mutex 要销毁的互斥锁
返回值：成功  0
失败  非零

6、trylock
int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：类似加锁函数效果，唯一区别就是不阻塞。
参数：mutex 用来加锁的互斥锁
返回值：成功 0
失败非零
E_AGAIN

线程的同步 ===》同步
  ===》有一定先后顺序的对资源的排他性访问。

原因：互斥锁可以控制排他访问但没有次序。

linux下的线程同步  ===》信号量机制 ===》semaphore.h   posix
sem_open();
信号量的分类：
1、无名信号量 ==》线程间通信
2、有名信号量 ==》进程间通信

框架：
信号量的定义 ===》信号量的初始化 ==》信号量的PV操作
===》信号量的销毁。

semaphore
1、信号量的定义：
   sem_t            sem;
   信号量的类型     信号量的变量

  如果sem有资源(==1)，则申请该资源，程序继续运行
  如果sem没有资源(==0)，则线程阻塞等待，一旦有资源
  则自动申请资源并继续运行程序。

  注意：sem 申请资源后会自动执行 sem = sem - 1;
参数：sem 要判断的信号量资源
返回值：成功 0
失败 -1

int sem_post(sem_t *sem);
功能：函数可以将指定的sem信号量资源释放
  并默认执行，sem = sem+1;
  线程在该函数上不会阻塞。
参数：sem 要释放资源的信号量
返回值：成功 0
失败 -1；

4、信号量的销毁
   int sem_destroy(sem_t *sem);
   功能：使用完毕将指定的信号量销毁
   参数：sem要销毁的信号量
   返回值：成功 0
失败  -1；

pthread_attr_t attr;
int pthread_attr_init(pthread_attr_t *attr);

  int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachst
ate)
功能：设置线程为分离的属性，线程自己在消亡的时候，释放相关的资源。
attr，出参，由该函数填充。
detachstate
PTHREAD_CREATE_DETACHED：
设置分离属性的标记
PTHREAD_CREATE_JOINABLE：
设置关联的属性：

返回  0 成功
      >0 失败，以及错误号

int pthread_detach(pthread_t thread);
功能：设置线程为分离的属性，线程自己在消亡的时候，释放相关的资源。
参数：thread，需要设置分离属性的tid

返回  0 成功
      >0 失败，以及错误号

pthread_yield();usleep(1000);
功能：本线程放弃cpu的调度。

产生死锁的原因主要是：
（1）因为系统资源不足。
（2）进程运行推进的顺序不合适。
（3）资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则
就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。
产生死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。