2。 使用ps命令，具体用法是 ps -xH
这样可以查看所有存在的线程，也可以使用grep作进一步的过滤。
3。 使用ps命令，具体用法是 ps -mq PID
这样可以看到指定的进程产生的线程数目。
更进一步，其实一些系统监控工具，在本质上也是读取的系统产生的文件罢了。比如说进程这个事情，
看看这个目录吧，/proc/5000/ 这里面有你所有想要的。其实stat代表着当前的一些信息。
使用ps命令来查看进程的时候，进程状态分别对应的含义如下：
D 不可中断睡眠 (通常是在IO *** 作) 收到信号不唤醒和不可运行, 进程必须等待直到有中断发生
R 正在运行或可运行（在运行队列排队中）
S 可中断睡眠 (休眠中, 受阻, 在等待某个条件的形成或接受到信号)
T 已停止的 进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行
W 正在换页(2.6.内核之前有效)
X 死进程 (未开启)
Z 僵尸进程 进程已终止, 但进程描述符存在, 直到父进程调用wait4()系统调用后释放BSD风格的
<高优先级(not nice to other users)
N 低优先级(nice to other users)
L 页面锁定在内存（实时和定制的IO）
s 一个信息头
l 多线程（使用 CLONE_THREAD，像NPTL的pthreads的那样）
+ 在前台进程组
linux多线程1.线程概述
线程是一个进程内的基本调度单位，也可以称为轻量级进程。线程是在共享内存空间中并发的多道执行路径，它们共享一个进程的资源，如文件描述和信号处理。因此，大大减少了上下文切换的开销。一个进程可以有多个线程，也就
是有多个线程控制表及堆栈寄存器，但却共享一个用户地址空间。
2.线程实现
线程创建pthread_create()
所需头文件#include
<pthread.h>
函数原型int
pthread_create
((pthread_t
*thread,
pthread_attr_t
*attr,
thread：线程标识符
attr：线程属性设置
start_routine：线程函数的起始地址
arg：传递给start_routine的参数
函数返回值
成功：0
出错：-1
线程退出pthread_exit()
所需头文件#include
<pthread.h>
函数原型void
pthread_exit(void
*retval)
函数传入值retval:pthread_exit()调用者线程的返回值，可由其他函数如pthread_join
来检索获取
等待线程退出并释放资源pthread_join()
所需头文件#include
<pthread.h>
函数原型int
pthread_join
((pthread_t
th,
void
**thread_return))
函数传入值
th：等待线程的标识符
thread_return：用户定义的指针，用来存储被等待线程的返回值（不为NULL时）
函数返回值
成功：0
出错：-1
代码举例
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
/*线程1*/
6.
void
thread1()
7.
{
8.
int
i=0
9.
10.
while(1)
11.
{
12.
printf(thread1:%d/n,i)
13.
if(i>3)
14.
pthread_exit(0)
15.
i++
16.
sleep(1)
17.
}
18.
}
19.
20.
/*线程2*/
21.
void
thread2()
22.
{
23.
int
i=0
24.
25.
while(1)
26.
{
27.
printf(thread2:%d/n,i)
28.
if(i>5)
29.
pthread_exit(0)
30.
i++
31.
sleep(1)
32.
}
33.
}
34.
35.
int
main()
36.
{
37.
pthread_t
t1,t2
38.
39.
/*创建线程*/
40.
pthread_create(&t1,NULL,(void
*)thread1,NULL)
41.
pthread_create(&t2,NULL,(void
*)thread2,NULL)
42.
/*等待线程退出*/
43.
pthread_join(t1,NULL)
44.
pthread_join(t2,NULL)
45.
return
0
46.
}
3同步与互斥
<1>互斥锁
互斥锁的 *** 作主要包括以下几个步骤。
•
互斥锁初始化：pthread_mutex_init
•
互斥锁上锁：pthread_mutex_lock
•
互斥锁判断上锁：pthread_mutex_trylock
•
互斥锁接锁：pthread_mutex_unlock
•
消除互斥锁：pthread_mutex_destroy
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0/*共享变量*/
6.
pthread_mutex_t
mutex=PTHREAD_MUTEX_INITIALIZER/*互斥锁*/
7.
8.
void
thread1()
9.
{
10.
int
ret
11.
while(1)
12.
{
13.
14.
15.
ret=pthread_mutex_trylock(&mutex)/*判断上锁*/
16.
17.
if(ret!=EBUSY)
18.
{
19.
pthread_mutex_lock(&mutex)/*上锁*/
20.
printf(This
is
thread1:%d/n,i)
21.
i++
22.
pthread_mutex_unlock(&mutex)/*解锁*/
23.
}
24.
sleep(1)
25.
}
26.
}
27.
28.
void
thread2()
29.
{int
ret
30.
while(1)
31.
{
32.
33.
ret=pthread_mutex_trylock(&mutex)
34.
if(ret!=EBUSY)
35.
{
36.
pthread_mutex_lock(&mutex)
37.
printf(This
is
thread2:%d/n,i)
38.
i++
39.
pthread_mutex_unlock(&mutex)
40.
}
41.
sleep(1)
42.
}
43.
}
44.
int
main()
45.
{
46.
pthread_t
t1,t2
47.
pthread_mutex_init(&mutex,NULL)
48.
pthread_create(&t1,NULL,(void
*)thread1,NULL)
49.
pthread_create(&t2,NULL,(void
*)thread2,NULL)
50.
51.
pthread_join(t1,NULL)
52.
pthread_join(t2,NULL)
53.
54.
pthread_mutex_destroy(&mutex)
55.
return
0
56.
}
<2>信号量
未进行同步处理的两个线程
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0
6.
void
thread1()
7.
{
8.
9.
while(1)
10.
{
11.
printf(This
is
thread1:%d/n,i)
12.
i++
13.
sleep(1)
14.
}
15.
}
16.
17.
18.
void
thread2()
19.
{
20.
21.
while(1)
22.
{
23.
printf(This
is
thread2:%d/n,i)
24.
i++
25.
sleep(1)
26.
}
27.
}
28.
29.
int
main()
30.
{
31.
pthread_t
t1,t2
32.
33.
pthread_create(&t1,NULL,(void
*)thread1,NULL)
34.
pthread_create(&t2,NULL,(void
*)thread2,NULL)
程序代码test.c共两个线程，一个主线程，一个读缓存区的线程：#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char globe_buffer[100]
void *read_buffer_thread(void *arg) //这里先声明一下读缓存的线程，具体实现写在后面了
int main()
{
int res,i
pthread_t read_thread
for(i=0i<20i++)
globe_buffer[i]=i
printf("\nTest thread : write buffer finish\n")
sleep(3)\\这里的3秒是多余，可以不要。
res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL)
if (res != 0)
{
printf("Read Thread creat Error!")
exit(0)
}
sleep(1)
printf("waiting for read thread to finish...\n")
res = pthread_join(read_thread, NULL)
if (res != 0)
{
printf("read thread join failed!\n")
exit(0)
}
printf("read thread test OK, have fun!! exit ByeBye\n")
return 0
}
void *read_buffer_thread(void *arg)
{
int i,x
printf("Read buffer thread read data : \n")
for(i=0i<20i++)
{
x=globe_buffer[i]
printf("%d ",x)
globe_buffer[i]=0//清空
}
printf("\nread over\n")
}
---------------------------------------------------------------------------------
以上程序编译：
gcc -D_REENTRANT test.c -o test.o –lpthread
运行这个程序：
$ ./test.o：
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）