以上就是给各位分享Java线程到Linux线程，其中也会对LWP的一对一映射进行解释，同时本文还将给你拓展AndroidC++系列：Linux线程（一）概念、AndroidC++系列：Linux线程（
以上就是给各位分享Java线程到Linux线程，其中也会对LWP的一对一映射进行解释，同时本文还将给你拓展Android C++系列：Linux线程（一）概念、Android C++系列：Linux线程（三）线程属性、Android C++系列：Linux线程（二）线程原语、Android C++系列：Linux线程（四）线程同步等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：- Java线程到Linux线程（LWP）的一对一映射（linux java线程）
- Android C++系列：Linux线程（一）概念
- Android C++系列：Linux线程（三）线程属性
- Android C++系列：Linux线程（二）线程原语
- Android C++系列：Linux线程（四）线程同步
Java线程到Linux线程（LWP）的一对一映射（linux java线程）
JavaThread对象和OS线程（轻量级进程）之间是否存在一对一的映射。也就是说，如果我有一个Thread对象，是否可以始终精确地标识一个关联的OS线程，并且我将始终具有相同的关联OS线程吗？通常，这取决于OS和JVM，因此我将问题限于使用Oracle和Open
JDK JVM的Linux。
怎么样的情况下，sleep荷兰国际集团和wait荷兰国际集团线程？还有尚未开始运行的线程和已经结束运行的线程的极端情况？
答案1
小编典典Java线程对象和OS线程之间是否存在一对一的映射（
是的，自Java 1.2起就存在。
在Java 1.2之前，使用了“绿色线程”模型，该模型将多个Java线程映射到一个OS线程。
Android C++系列：Linux线程（一）概念
1. 什么是线程
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
2. 线程和进程的关系
- 轻量级进程(light-weight process)，也有PCB,创建线程使用的底层函数和进程一 样，都是clone;
- 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的;
- 进程可以蜕变成线程;
- 在美国人眼里，线程就是寄存器和栈;
- 在linux下，线程最是小的执行单位;进程是最小的分配资源单位查看LWP号。
ps -Lf pid
ps -eLf![[Android C++系列：Linux线程（一）概念.png]]
3. 线程间共享资源
- 文件描述符表；
- 每种信号的处理方式；
- 当前工作目录；
- 用户ID和组ID；
- 内存地址空间
Text
data
bss
堆
共享库
4. 线程间非贡献资源
- 线程id;
- 处理器现场和栈指针(内核栈);
- 独立的栈空间(用户空间栈);
- errno变量;
- 信号屏蔽字;
- 调度优先级
5. 线程优缺点
优点：
- 提高程序的并发性；
- 开销小，不用重新分配内存；
- 通信和共享数据方便
缺点：
- 线程不稳定(库函数实现)；
- 线程调试比较困难(gdb支持不好)；
- 线程无法使用unix经典事件，例如信号
6. pthread manpage
查看manpage关于pthread的函数
man -k pthreadUbuntu可以通过以下命令安装man命令：sudo apt-get install manpages-posix manpages-posix-dev7. 总结
本文介绍了线程概念，线程和进程间关系，线程间共享资源和非共享资源，线程优缺点以及man工具的安装和使用。
Android C++系列：Linux线程（三）线程属性
linux下线程的属性是可以根据实际项目需要，进行设置，之前我们讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问 题。如我们对程序的性能提出更高的要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的使用，增加最大线程个数。
typedef struct {
int etachstate; //线程的分离状态
int schedpolicy; //线程调度策略
structsched_param schedparam; //线程的调度参数
int inheritsched; //线程的继承性
int scope;//线程的作用域
size_t guardsize;//线程栈末尾的警戒缓冲区大小
int stackaddr_set; //线程的栈设置
void* stackaddr; //线程栈的位置
size_t stacksize; //线程栈的大小
}pthread_attr_t; 注:目前线程属性在内核中不是直接这么定义的，抽象太深不便分析，为方便理解，我们使用早期的线程属性定义，两者之间定义的主要元素差别不大。
属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init， 这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释 放资源。线程属性主要包括如下属性:作用域(scope)、栈尺寸(stack size)、栈地址 (stack address)、优先级(priority)、分离的状态(detached state)、调度策略和 参数(scheduling policy and parameters)。默认的属性为非绑定、非分离、缺省M的堆 栈、与父进程同样级别的优先级。
1. 线程属性初始化
先初始化线程属性，再pthread_create创建线程
#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr); //初始化线程属性
int pthread_attr_destroy(pthread_attr_t *attr); //销毁线程属性所占用的资源2. 线程的分离状态(detached state)
线程的分离状态决定一个线程以什么样的方式来终止自己。
非分离状态:线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程 结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统 资源。
分离状态:分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。
线程分离状态的函数:
#include <pthread.h>
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); //设置线程属性，分离or非分离
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate); //获取程属性，分离or非分离
pthread_attr_t *attr:被已初始化的线程属性
int *detachstate:可选为PTHREAD_CREATE_DETACHED(分离线程)和 PTHREAD _CREATE_JOINABLE(非分离线程)这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快， 它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。 要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数 pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使 用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。
3. 线程的栈地址(stack address)
POSIX.1定义了两个常量_POSIX_THREAD_ATTR_STACKADDR 和_POSIX_THREAD_ATTR_STACKSIZE 检测系统是否支持栈属性。也可以给sysconf函数传递_SC_THREAD_ATTR_STACKADDR或 _SC_THREAD_ATTR_STACKSIZE 来进行检测。
当进程栈地址空间不够用时，指定新建线程使用由malloc分配的空间作为自己的栈空 间。通过pthread_attr_setstackaddr和pthread_attr_getstackaddr两个函数分别设置和获 取线程的栈地址。传给pthread_attr_setstackaddr函数的地址是缓冲区的低地址(不一定 是栈的开始地址，栈可能从高地址往低地址增长)。
include <pthread.h>
int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
int pthread_attr_getstackaddr(pthread_attr_t *attr, void **stackaddr);- attr: 指向一个线程属性的指针
- stackaddr: 返回获取的栈地址 返回值:若是成功返回0,否则返回错误的编号
- 说 明:函数已过时，一般用下面讲到的pthread_attr_getstack来代替
4. 线程的栈大小(stack size)
当系统中有很多线程时，可能需要减小每个线程栈的默认大小，防止进程的地址空间不 够用,当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线 程栈的默认大小。
函数pthread_attr_getstacksize和 pthread_attr_setstacksize提供设置。
#include <pthread.h>
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);- attr 指向一个线程属性的指针
- stacksize 返回线程的堆栈大小
- 返回值:若是成功返回0,否则返回错误的编号
除上述对栈设置的函数外，还有以下两个函数可以获取和设置线程栈属性
#include <pthread.h>
int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
int pthread_attr_getstack(pthread_attr_t *attr, void **stackaddr, size_t *stacksize);- attr 指向一个线程属性的指针
- stackaddr 返回获取的栈地址
- stacksize 返回获取的栈大小
- 返回值:若是成功返回0,否则返回错误的编号
5. 线程属性控制实例
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#define SIZE 0x10000
int print_ntimes(char *str) {
sleep(1);
printf("%s\n", str);
return 0;
}
void *th_fun(void *arg) {
int n = 3;
while (n--)
print_ntimes("hello xwp\n");
}
int main(void){
pthread_t tid;
int err, detachstate, i = 1;
pthread_attr_t attr;
size_t stacksize;
void *stackaddr;
pthread_attr_init(&attr);
pthread_attr_getstack(&attr, &stackaddr, &stacksize);
printf("stackadd=%p\n", stackaddr);
printf("stacksize=%x\n", (int)stacksize);
pthread_attr_getdetachstate(&attr, &detachstate);
if (detachstate == PTHREAD_CREATE_DETACHED)
printf("thread detached\n");
else if (detachstate == PTHREAD_CREATE_JOINABLE)
printf("thread join\n");
else
printf("thread un known\n");
/* 设置线程分离属性 */
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
while (1) {
/* 在堆上申请内存，指定线程栈的起始地址和大小 */
stackaddr = malloc(SIZE);
if (stackaddr == NULL) {
perror("malloc");
exit(1);
}
stacksize = SIZE;
pthread_attr_setstack(&attr, stackaddr, stacksize);
err = pthread_create(&tid, &attr, th_fun, NULL);
if (err != 0) {
printf("%s\n", strerror(err));
exit(1);
}
printf("%d\n", i++);
}
pthread_attr_destroy(&attr);
return 0;
}6. 线程其他注意事项
6.1 NPTL
- 察看当前pthread库版本
getconf GNU_LIBPTHREAD_VERSION - NPTL实现机制(POSIX),Native POSIX Thread Library
- 使用线程库时gcc指定 -lpthread
6.2 线程终止方式
如果需要只终止某个线程而不终止整个进程，可以有三种方法:
- 从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用 exit；
- 一个线程可以调用pthread_cancel终止同一进程中的另一个线程；
- 线程可以调用pthread_exit终止自己。
6.3 细节注意
- 主线程退出其他线程不退出，主线程应调用ptrhed_exit ；
避免僵线程：
- join
- pthread_deatch
- pthread_create指定分离属性
- 被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;
- malloc和mmap申请的内存可以被其他线程释放；
- 如果线程终止时没有释放加锁的互斥量，则该互斥量不能再被使用；
- 应避免在多线程模型中调用fork除非，马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit；
- 信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制
7. 总结
本文介绍了线程属性：线程属性初始化、线程的分离状态、线程的栈地址、线程的栈大小；还介绍了线程的NPTL、线程终止方式、注意细节等注意事项。
Android C++系列：Linux线程（二）线程原语
1. 创建线程 pthread_create
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
Compile and link with -lpthread.
typedef unsigned long int pthread_t;pthread_t *thread:传递一个pthread_t变量地址进来，用于保存新线程的tid(线程ID)const pthread_attr_t *attr:线程属性设置，如使用默认属性，则传NULLvoid *(*start_routine) (void *):函数指针，指向新线程应该加载执行的函数模块void *arg:指定线程将要加载调用的那个函数的参数 返回值:成功返回0，失败返回错误号。之前介绍的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变 量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其 它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。
在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create() 返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针 start_routine 决 定。start_routine 函 数 接 收 一 个 参 数， 是 通 过 pthread_create 的 arg 参 数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定 义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine 返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态，下面会详细介绍pthread_join。
pthread_create成功返回后，新创建的线程的id被填写到thread参数所指向的内存单元。我们知道进程id的类型是pid_t，每个进程的id在整个系统中是唯一的，调用getpid(2) 可以获得当前进程的id，是一个正整数值。线程id的类型是thread_t，它只在当前进程中保证是唯一的，在不同的系统中thread_t这个类型有不同的实现，它可能是一个整数值， 也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印，调用 pthread_self(3)可以获得当前线程的id。
attr参数表示线程属性，我们不深入讨论线程属性，所有代码例子都传NULL给attr参数，表示线程属性取缺省值，感兴趣的朋友可以参考[APUE2e]。
2. pthread_self
获取调用线程tid
#include <pthread.h>
pthread_t pthread_self(void);思考:pthread_self获得的tid和pthread_create函数里得到tid是否会出现不一致?
首先看一个简单的例子:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
pthread_t ntid;
void printids(const char *s) {
pid_t pid;
pthread_t tid;
pid = getpid();
tid = pthread_self();
printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,(unsigned int)tid, (unsigned int)tid);
}
void *thr_fn(void *arg) {
printids(arg);
return NULL;
}
int main(void) {
int err;
err = pthread_create(&ntid, NULL, thr_fn, "new thread: ");
if (err != 0) {
fprintf(stderr, "can''t create thread: %s\n", strerror(err));
exit(1);
}
printids("main thread:");
sleep(1);
return 0;
}由于pthread_create的错误码不保存在errno中，因此不能直接用perror(3)打印错误信 息，可以先用strerror(3)把错误码转换成错误信息再打印。
如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函 数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，我们在main函 数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新 创建的线程执行，后面我们会看到更好的办法。
3. pthread_exit
调用线程退出函数，注意和exit函数的区别，任何线程里exit导致进程退出，其他线程 未工作结束，主控线程退出时不能return或exit。
需要注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是 用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函 数已经退出了。
#include <pthread.h>
void pthread_exit(void *retval);void *retval:线程退出时传递出的参数，可以是退出值或地址，如是地址时，不能是线程内部申请的局部地址。
4. pthread_join
#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
pthread_t thread:回收线程的tidvoid **retval:接收退出线程传递出的返回值- 返回值:成功返回0，失败返回错误号
调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下:
- 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返 回值。
- 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存 放的是常数PTHREAD_CANCELED。
- 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给 pthread_exit的参数。
- 如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。
5. pthread_cancel
在进程内某个线程可以取消另一个线程。
#include <pthread.h>
int pthread_cancel(pthread_t thread);被取消的线程，退出值，定义在Linux的pthread库中常数PTHREAD_CANCELED的值是-1。 可以在头文件pthread.h中找到它的定义:
#define PTHREAD_CANCELED ((void *) -1)实例：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *thr_fn1(void *arg) {
printf("thread 1 returning\n");
return (void *)1;
}
void *thr_fn2(void *arg) {
printf("thread 2 exiting\n");
pthread_exit((void *)2);
}
void *thr_fn3(void *arg) {
while(1) {
printf("thread 3 writing\n");
sleep(1);
}
}
int main(void) {
pthread_t tid;
void *tret;
pthread_create(&tid, NULL, thr_fn1, NULL); pthread_join(tid, &tret);
printf("thread 1 exit code %d\n", (int)tret);
pthread_create(&tid, NULL, thr_fn2, NULL); pthread_join(tid, &tret);
printf("thread 2 exit code %d\n", (int)tret);
pthread_create(&tid, NULL, thr_fn3, NULL); sleep(3);
pthread_cancel(tid);
pthread_join(tid, &tret);
printf("thread 3 exit code %d\n", (int)tret);
return 0;
}6. pthread_detach
#include <pthread.h>
int pthread_detach(pthread_t tid); pthread_t tid:分离线程tid 返回值:成功返回0，失败返回错误号。
一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取 它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收 它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用 pthread_join，这样的调用将返回EINVAL。如果已经对一个线程调用了pthread_detach就不 能再调用pthread_join了。
示例：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
void *thr_fn(void *arg)
{
int n = 3;
while (n--) {
printf("thread count %d\n", n);
sleep(1);
}
return (void *)1;
}
int main(void) {
pthread_t tid;
void *tret;
int err;
pthread_create(&tid, NULL, thr_fn, NULL); //第一次运行时注释掉下面这行，第二次再打开，分析两次结果
pthread_detach(tid);
while (1) {
err = pthread_join(tid, &tret);
if (err != 0)
fprintf(stderr, "thread %s\n", strerror(err));
else
fprintf(stderr, "thread exit code %d\n", (int)tret);
sleep(1);
}
return 0;
}7. pthread_equal
比较两个线程是否相等
#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);8. 总结
本文介绍了linux 线程相关的七个函数：创建线程pthread_create、pthread_self、pthread_exit、pthread_join、pthread_cancel、pthread_detach、pthread_equal。
Android C++系列：Linux线程（四）线程同步
多个线程同时访问共享数据时可能会冲突，这跟我们前面信号文章所说的可重入性是同样的问题。比如两个线程都要把某个全局变量增加1，这个操作在某平台需要三条指令完成:
- 从内存读变量值到寄存器；
- 寄存器的值加1；
- 将寄存器的值写回内存
假设两个线程在多处理器平台上同时执行这三条指令，则可能导致下图所示的结果，最后变量只加了一次而非两次。
实例：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NLOOP 5000 int counter;
void *doit(void *);
/* incremented by threads */
int main(int argc, char **argv) {
pthread_t tidA, tidB;
pthread_create(&tidA, NULL, &doit, NULL);
pthread_create(&tidB, NULL, &doit, NULL);
/* wait for both threads to terminate */
pthread_join(tidA, NULL);
pthread_join(tidB, NULL);
return 0;
}
void *doit(void *vptr) {
int i, val;
for (i = 0; i < NLOOP; i++) {
val = counter;
printf("%x: %d\n", (unsigned int)pthread_self(), val + 1);
counter = val + 1;
}
return NULL;
}我们创建两个线程，各自把counter增加5000次，正常情况下最后counter应该等于 10000，但事实上每次运行该程序的结果都不一样，有时候数到5000多，有时候数到6000 多。
1. 线程为什么要同步
- 共享资源，多个线程都可对共享资源操作；
- 线程操作共享资源的先后顺序不确定；
- 处理器对存储器的操作一般不是原子操作。
2. 互斥量
mutex操作原语：
- pthread_mutex_t
- pthread_mutex_init
- pthread_mutex_destroy
- pthread_mutex_lock
- pthread_mutex_trylock
- pthread_mutex_unlock
2.1 临界区（Critical Section）
保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共 享资源进行访问。如果有多个线程试图同时访问临界区，那么 在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。
2.2 临界区的选定
临界区的选定因尽可能小，如果选定太大会影响程序的并行处理性能。
2.3 互斥量实例
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);实例：
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NLOOP 5000
int counter; /* incremented by threads */
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void *doit(void *);
int main(int argc, char **argv) {
pthread_t tidA, tidB;
pthread_create(&tidA, NULL, doit, NULL);
pthread_create(&tidB, NULL, doit, NULL);
/* wait for both threads to terminate */
pthread_join(tidA, NULL);
pthread_join(tidB, NULL);
return 0;
}
void *doit(void *vptr) {
int i, val;
for (i = 0; i < NLOOP; i++) {
pthread_mutex_lock(&counter_mutex);
val = counter;
printf("%x: %d\n", (unsigned int)pthread_self(), val + 1);
counter = val + 1;
pthread_mutex_unlock(&counter_mutex);
}
return NULL;
}这样运行结果就正常了，每次运行都能数到10000。
3. 死锁
- 同一个线程在拥有A锁的情况下再次请求获得A锁；
- 线程一拥有A锁，请求获得B锁;线程二拥有B锁，请求获得A锁死锁导致的结果是什么?
4. 读写锁
读共享，写独占
- pthread_rwlock_t
- pthread_rwlock_init
- pthread_rwlock_destroy
- pthread_rwlock_rdlock
- pthread_rwlock_wrlock
- pthread_rwlock_tryrdlock
- pthread_rwlock_trywrlock
- pthread_rwlock_unlock
实例：
#include <stdio.h>
#include <pthread.h>
int counter;
pthread_rwlock_t rwlock; //3个线程不定时写同一全局资源，5个线程不定时读同一全局资源
void *th_write(void *arg)
{
int t;
while (1) {
pthread_rwlock_wrlock(&rwlock);
t = counter;
usleep(100);
printf("write %x : counter=%d ++counter=%d\n", (int)pthread_self(), t, ++counter);
pthread_rwlock_unlock(&rwlock);
usleep(100);
}
}
void *th_read(void *arg) {
while (1) {
pthread_rwlock_rdlock(&rwlock);
printf("read %x : %d\n", (int)pthread_self(), counter);
pthread_rwlock_unlock(&rwlock);
usleep(100);
}
}
int main(void) {
int i;
pthread_t tid[8];
pthread_rwlock_init(&rwlock, NULL);
for (i = 0; i < 3; i++)
pthread_create(&tid[i], NULL, th_write, NULL);
for (i = 0; i < 5; i++)
pthread_create(&tid[i+3], NULL, th_read, NULL);
pthread_rwlock_destroy(&rwlock);
for (i = 0; i < 8; i++)
pthread_join(tid[i], NULL);
return 0;
}5. 条件变量
条件变量给多个线程提供了一个汇合的场所,条件变量控制原语:
- pthread_cond_t
- pthread_cond_init
- pthread_cond_destroy
- pthread_cond_wait
- pthread_cond_timedwait
- pthread_cond_signal
- pthread_cond_broadcast
生产者消费者模型:
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
struct msg {
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p) {
struct msg *mp;
for (;;) {
pthread_mutex_lock(&lock);
while (head == NULL)
pthread_cond_wait(&has_product, &lock);
mp = head;
head = mp->next;
pthread_mutex_unlock(&lock);
printf("Consume %d\n", mp->num); free(mp);
sleep(rand() % 5);
}
}
void *producer(void *p) {
struct msg *mp;
for (;;) {
mp = malloc(sizeof(struct msg));
mp->num = rand() % 1000 + 1;
printf("Produce %d\n", mp->num);
pthread_mutex_lock(&lock);
mp->next = head;
head = mp;
pthread_mutex_unlock(&lock);
pthread_cond_signal(&has_product);
sleep(rand() % 5);
}
}
int main(int argc, char *argv[]) {
pthread_t pid, cid;
srand(time(NULL));
pthread_create(&pid, NULL, producer, NULL);
pthread_create(&cid, NULL, consumer, NULL);
pthread_join(pid, NULL);
pthread_join(cid, NULL);
return 0;
}6. 信号量
信号量控制原语
- sem_t
- sem_init
- sem_wait
- sem_trywait
- sem_timedwait
- sem_post
- sem_destroy
生产者消费者实例：
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#define NUM 5
int queue[NUM];
sem_t blank_number, product_number;
void *producer(void *arg) {
int p = 0;
while (1) {
sem_wait(&blank_number);
queue[p] = rand() % 1000 + 1;
printf("Produce %d\n", queue[p]);
sem_post(&product_number);
p = (p+1)%NUM;
sleep(rand()%5);
}
}
void *consumer(void *arg) {
int c = 0;
while (1) {
sem_wait(&product_number);
printf("Consume %d\n", queue[c]); queue[c] = 0; sem_post(&blank_number);
c = (c+1)%NUM;
sleep(rand()%5);
}
}
int main(int argc, char *argv[]) {
pthread_t pid, cid;
sem_init(&blank_number, 0, NUM);
sem_init(&product_number, 0, 0);
pthread_create(&pid, NULL, producer, NULL);
pthread_create(&cid, NULL, consumer, NULL);
pthread_join(pid, NULL);
pthread_join(cid, NULL);
sem_destroy(&blank_number);
sem_destroy(&product_number);
return 0;
}7. 进程间锁
7.1 进程间pthread_mutex
#include <pthread.h>
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);pshared:
- 线程锁:PTHREAD_PROCESS_PRIVATE ;
- 进程锁:PTHREAD_PROCESS_SHARED；
- 默认情况是线程锁
实例：
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void) {
int fd, i;
struct mt *mm;
pid_t pid;
fd = open("mt_test", O_CREAT | O_RDWR, 0777);
/* 不需要write,文件里初始值为0 */
ftruncate(fd, sizeof(*mm));
mm = mmap(NULL, sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
close(fd);
memset(mm, 0, sizeof(*mm));
/* 初始化互斥对象属性 */
pthread_mutexattr_init(&mm->mutexattr);
/* 设置互斥对象为PTHREAD_PROCESS_SHARED共享，即可以在多个进程的线程访问,PTHREAD_PROCESS_PRIVATE 为同一进程的线程共享 */
pthread_mutexattr_setpshared(&mm->mutexattr,PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&mm->mutex, &mm->mutexattr);
pid = fork();
if (pid == 0){
/* 加10次。相当于加10 */
for (i=0;i<10;i++){
pthread_mutex_lock(&mm->mutex);
(mm->num)++;
printf("num++:%d\n",mm->num);
pthread_mutex_unlock(&mm->mutex);
sleep(1);
}
}else if (pid > 0) {
/* 父进程完成x+2,加10次，相当于加20 */
for (i=0; i<10; i++){
pthread_mutex_lock(&mm->mutex);
mm->num += 2;
printf("num+=2:%d\n",mm->num);
pthread_mutex_unlock(&mm->mutex);
sleep(1);
}
wait(NULL);
}
pthread_mutex_destroy(&mm->mutex);
pthread_mutexattr_destroy(&mm->mutexattr);
/* 父子均需要释放 */
munmap(mm,sizeof(*mm));
unlink("mt_test");
return 0;
}7.2 文件锁
使用fcntl提供文件锁
struct flock {
...
short l_type; /*Type of lock: F_RDLCK, F_WRLCK, F_UNLCK */
short l_whece; /* How to interpret l_start: SEEK_SET,SEEK_CUR,SEEK_END */
off_t l_start; /* Starting offset for lock*/
off_t l_len; /*Number of bytes to lock*/
pid_t l_pid; /* PID of process blocking our lock (F_GETLK only) */实例：
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
void sys_err(char *str) {
perror(str);
exit(1);
}
int main(int argc, char *argv[]) {
int fd;
struct flock f_lock;
if (argc < 2) {
printf("./a.out filename\n");
exit(1);
}
if ((fd = open(argv[1], O_RDWR)) < 0)
sys_err("open");
//f_lock.l_type = F_WRLCK;
f_lock.l_type = F_RDLCK;
f_lock.l_whence = SEEK_SET;
f_lock.l_start = 0;
f_lock.l_len = 0; //0表示整个文件加锁
fcntl(fd, F_SETLKW, &f_lock);
printf("get flock\n");
sleep(10);
f_lock.l_type = F_UNLCK;
fcntl(fd, F_SETLKW, &f_lock);
printf("un flock\n");
close(fd);
return 0;
}8. 总结
本文介绍了线程同步机制：为什么要同步、互斥量、死锁、读写锁、条件变量、信号量、进程间锁等概念与机制以及相关示例。
今天关于Java线程到Linux线程和LWP的一对一映射的分享就到这里，希望大家有所收获，若想了解更多关于Android C++系列：Linux线程（一）概念、Android C++系列：Linux线程（三）线程属性、Android C++系列：Linux线程（二）线程原语、Android C++系列：Linux线程（四）线程同步等相关知识，可以在本站进行查询。
本文标签：
