1L防偷窥

/*linux下最常用的应该就是pthread线程库了
本教程就是关于pthread的
关于线程是什么东西我就不赘述了 百科上都有*/
#include<stdio.h>
#include<pthread.h>//pthread库的头文件
//声明并定义一个函数
void*function(void*data)
{
printf("start\n");
printf("function:%d\n",*(int*)(data));
printf("end\n");
return data;
}
int main()
{
pthread_t tid;
//*声明一个pthread_t类型变量
//*相当于一个线程的id
//*它在头文件中的定义是 typedef long pthread_t
int n=123;
//先不要管这货是干嘛的
pthread_create(&tid,NULL,function,&n);
/*
这个函数创建一个线程
第一个参数以指针传递，并且返回线程号
第二个参数是线程的属性设置 现在我们设置成NULL表示使用默认属性
第三个参数是一个函数指针 void*(*func)(void*) 它和我们在main()前面定义的函数的格式是一样的 现在把function作为参数传入 表示线程从这个函数开始执行 这个函数return就相当于线程结束
最后一个参数是 void* 这个指针是传递给上面那个函数的 是给用户自己定义的数据使用的 在这里我传递了一个int变量n的地址
在这个函数返回前，我们创建的线程可能已经在执行了
*/
printf("this is main()\n");
int *p;
pthread_join(tid,(void**)&p);
/*
等待一个线程的结束或者对已经结束的进程进行清理操作
第一个参数是我们要等待的线程号
第二个参数是一个 void** ，它用于接受线程的返回值
在这里是 function的返回值
*/
printf("main:%d",*p);
return 0;
}

调用 pthread_join()的线程会阻塞 直的指定等待的进程结束 如果指定的进程已经结束那么它会直接返回
如果主线程没有调用 pthread_join() 且主线程执行比子线程执行快的话 主线程的结束会使整个程序结束

int pthread_create(pthread_t *thread, pthread_attr_t const * attr,
void *(*start_routine)(void *), void * arg);
void pthread_exit(void * retval);
int pthread_join(pthread_t thid, void ** ret_val);
//以上出现的函数的原型
//pthread_exit();是结束调用进程的 相当于 return

pthread_t pthread_self(void); //这个函数返回调用线程的线程号

如果你学会了以上函数的使用，你现在就可以写出并行的程序而且不用重新开一个进程

以上是线程的基本使用方法
以下是互斥锁的基本使用方法

好吧，楼主睡着了，插一下…

互斥锁是用于线程间的同步和重要数据的读写保护
例如在多个线程共享一个数据的时候
A线程要对数据进行读写 读写操作是多个cpu指令组成
在读写操作执行到一半时 A的时间片用完了
内核把上下文切换到了B线程
恰好B线程也要对这个数据进行读写
这时就有可能出现问题
还有就是不可重入的函数的问题
这些都可以用互斥锁来解决

这些是一会将要用到的函数
int pthread_mutex_init(pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr);
初始化一个互斥锁变量 第二个参数是互斥锁的属性定义
设定为NULL表示使用默认属性
int pthread_mutex_destroy(pthread_mutex_t *mutex);
注销一个互斥锁变量
int pthread_mutex_lock(pthread_mutex_t *mutex);
对互斥锁上锁 如果互斥锁已经上锁，则调用此函数的线程将会
阻塞直到拥有锁的线程解锁 如果一个线程连续调用
两次则会造成死锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
对互斥锁解锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
对互斥锁上锁
不过与pthread_mutex_lock()不同的是:它在调用后如果这个锁已经上锁则这个函数回直接返回而不是阻塞
以上函数成功返回0失败返回错误码

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
pthread_mutex_t mutex;
//声明一个全局互斥锁变量
//这次要使用两个线程 所以定义了两个函数
void*func1(void*data)
{
usleep(1);
pthread_mutex_lock(&mutex);
for(int n=0;n<5;n++)
{
printf("func1:%d\n",n);
}
pthread_mutex_unlock(&mutex);
return NULL;
//pthread_exit(NULL);
}
void*func2(void*data)
{
usleep(1);
pthread_mutex_lock(&mutex);
for(int n=0;n<5;n++)
{
printf("func2:%d\n",n);
}
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
//return NULL;
}
int main()
{
pthread_t tid1,tid2;
pthread_mutex_init(&mutex,NULL);
pthread_create(&tid1,NULL,func1,NULL);
pthread_create(&tid2,NULL,func2,NULL);
usleep(1);
pthread_mutex_lock(&mutex);
printf("this is main()\n");
pthread_mutex_unlock(&mutex);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
pthread_mutex_destroy(&mutex);
return 0;
}

这是上面示例程序的输出:
func1:0
func1:1
func1:2
func1:3
func1:4
func2:0
func2:1
func2:2
func2:3
func2:4
this is main()
func1和func2并没有交叉着"数数"而是一个数完，然后是另一个
试着注释掉那些加锁和解锁的语句并运行再看看输出
你就会明白互斥锁的作用了

支持一个

明天早上起来继续写

默默顶一下。。。。。。。。因为没有书，果断放弃了linux下的c。。。。。。。。。。。。。@DXKite @啊o额iu鱼

来了，帮顶……
/**
✎﹏﹏……﹍﹍
﹏﹏﹏啊o额iu鱼✍
*/

顶
　　　——to live is to change the world

最多能有几个线程？这些线程的计算是怎么分配给CPU的？

/*条件变量是线程间通过一些全局变量来进行同步的机制
主要有两种动作 等待条件成立，发送条件成立信号
由于条件变量本身就是一种资源，为了防止多个线程同时
开始等待条件变量成立(注意:是同时开始)，所以条件变量
总是和一个互斥锁配和使用*/
/*将会用到的函数的原型*/
int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *attr);
//初始化条件变量 attr设置为NULL表示使用默认属性
int pthread_cond_destroy(pthread_cond_t *cond);
//注销一个条件变量
int pthread_cond_broadcast(pthread_cond_t *cond);
//发送一个条件成立的信号唤醒所有等待中的线程
int pthread_cond_signal(pthread_cond_t *cond);
//发送一个条件成立信号唤醒一个正在等待的线程
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
//等待条件变量成立 在条件成立之前线程进入阻塞状态
//条件成立后 此函数会返回 线程被唤醒
int pthread_cond_timedwait(pthread_cond_t *cond,
pthread_mutex_t * mutex,
const struct timespec *abstime);
//等待条件变量成立 在条件成立后此函数返回
//或者是超过了给定的时间点 此函数返回ETIMEOUT
//abs的意义是和调用time()获得的时间意义相同
//是一个时间点

我们在使用 pthread_cond_wait()或者
pthread_cond_timedwait()前要对与之配对的
互斥锁进行加锁操作(pthread_mutex_lock())，
并且在这两个函数返回后进行解锁操作