线程linux

❶ linux线程如何运行

pthread_create执行后，如果执行成功会生成一个子线程 也就是现在有两个线程同时运行
父线程还会继续执行后面的代码 直到结束
子线程则开始执行thread函数体里的代码了 别的不执行
pthread_join会按照父线程执行顺序 到它了就会执行 该函数的作用是阻塞等待一个线程执行完毕
在你的代码里 不一定在子线程执行3次后才启动 也可能子线程没有执行呢 父线程就执行到pthread_join了 然后阻塞等待子线程
如果你想让pthread_join在子线程3次执行后才启动 可以让父线程sleep下 不过子线程执行完了 你再执行pthread_join也就没有什么意义了
不懂再问

❷ linux中的线程有哪几种状态

就绪：线程分配了CPU以外的全部资源，等待获得CPU调度
执行：线程获得CPU，正在执行
阻塞：线程由于发生I/O或者其他的操作导致无法继续执行，就放弃处理机，转入线程就绪队列
挂起：由于终端请求，操作系统的要求等原因，导致挂起。

❸ Linux中进程和线程的对比与区别

线程和进程是另一对有意义的概念，主要区别和联系如下：

• 进程是操作系统进行资源分配的基本单位，拥有完整的进程空间。进行系统资源分配的时候，除了CPU资源之外，不会给线程分配独立的资源，线程所需要的资源需要共享。

• 线程是进程的一部分，如果没有进行显示的线程分配，可以认为进程是单线程的；如果进程中建立了线程，则可认为系统是多线程的。

• 多线程和多进程是两种不同的概念。多线程与多进程有不同的资源共享方式。

• 进程有进程控制块PCB，系统通过PCB对进程进行调度。进程有线程控制块TCP，但TCB所表示的状态比PCB要少的多。

❹ Linux到底有没有线程

线程只是一个概念，Linux视线程和进程是一样的，所以它只需要一个“进程”的概念，Windows视线程为进程生成的更小粒度单位。
所以其实大家只是看待问题角度不同，不代表Linux“没有”线程

❺ java的多线程与linux的多线程的关系

java自己实现了线程库，也就是说java的线程并不和操作系统的线程对应，jvm在操作系统上面是一个进程，当这个进程被操作系统调度到后，jvm内部实现的线程库再调度java线程，为什么是这样呢？考虑到以前的操作系统内核，比如linux，在以前都不直接支持线程，用户线程和内核线程是多对一的关系，solaris一度也是这样，所以java当然心有余而力不足了，你操作系统都不能完美支持线程，你让我实现不是难为我吗？在那个年代，java多线程的调度完全是自主的，操作系统根本不知道java是多线程的，调度策略完全自己实现，单cpu下肯定是分时的，多cpu下就看jvm会不会建立多cpu上的多jvm实例了。
到了后来，操作系统内核纷纷都支持了多线程（windows开始就支持），那么java也要考虑推卸一些责任了，这样java线程就和操作系统线程一一对应或多多对应了，这个时候，如果是一一对应，那么线程的调度完全交给了操作系统内核，当然jvm还保留一些策略足以影响到其内部的线程调度，举个例子，在linux下，只要一个Thread.run就会调用一个fork产生一个线程。
问：java获得cup使用权采用的抢占机制，使用cup的时候是分时机制，这句话对不对？
答：部分对，早期实现，基本可以实现抢占式，但是现代实现，如果系统不支持抢占，那么jvm也无所谓抢占了。
问：多线程使用cup和使用的操作系统有关还是java机制有关（xp是什么机制）
答：早期是java机制实现，现在大部分是操作系统实现的，java机制仅仅保留了相关策略从而影响调度；xp是基于优先级的抢占式调度，其性能很大程度依赖于动态优先级提升

❻ Linux线程的几种结束方式

Linux线程的几种结束方式
Linux创建线程使用
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void *), void *arg)
1
2
Linux线程的几种结束方式：
调用pthread_exit(exit_code)，exit_code为线程退出的状态代码。同一进程下的其他线程可以通过pthread_join(exit_code)来使用。
函数start_routine使用return返回，与调用pthread_exit()作用相同。
线程被取消pthread_cancel()。
同一进程中的其他线程调用了exit(),，或者主线程从main函数返回。

❼ linux 最多支持多少个线程

默认情况下：
主线程＋辅助线程 ＋<253个自己的线程<＝255
含主线程和一个辅助线程，最多255个，即一个用户只能生成253个线程。
Linux最大线程数限制及当前线程数查询：
1、总结系统限制有：
/proc/sys/kernel/pid_max #查系统支持的最大线程数，一般会很大，相当于理论值
/proc/sys/kernel/thread-max
max_user_process（ulimit -u） #系统限制某用户下最多可以运行多少进程或线程
/proc/sys/vm/max_map_count
硬件内存大小
2、Java虚拟机本身限制：
-Xms #intial java heap size
-Xmx #maximum java heap size
-Xss #the stack size for each thread
3、查询当前某程序的线程或进程数
pstree -p `ps -e | grep java | awk '{print $1}'` | wc -l 或 pstree -p 3660 | wc -l
4、查询当前整个系统已用的线程或进程数
pstree -p | wc -l
1、 cat /proc/${pid}/status
2、pstree -p ${pid}
3、top -p ${pid} 再按H 或者直接输入 top -bH -d 3 -p ${pid}
top -H
手册中说：-H : Threads toggle
加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。
4、ps xH
手册中说：H Show threads as if they were processes
这样可以查看所有存在的线程。
5、ps -mp <PID>
手册中说：m Show threads after processes
这样可以查看一个进程起的线程数。

❽ linux终端中如何查看用了多少个线程

1、top -H
top命令是linux下常用的性能分析工具，也是一个强大的系统检测工具，能够实时显示系统中各个进程的资源占用状况，类似于Windows的任务管理器
-H : Threads toggle是否显示线程，为on时将显示所有线程
2、ps xH
ps查看当前用户的活动进程
-H： Show threads as if they were processes
查看所有存在的线程。
3、ps -mp <PID>
-m： Show threads after processes
查看某个进程的线程

❾ Linux线程及同步

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);