精华内容
下载资源
问答
  • 2020-06-03 17:06:09

    进程是系统对应用程序的封装,是系统进行资源调度和分配的基本单位,实现了操作系统的并发。
    线程是进程的子任务,是cpu进行调度和分配的进本单位,实现进程内部的并发,线程是操作系统可识别的最小执行和调度单位,每个线程都独自占用一个虚拟处理器:独立的寄存器组,指令计数器和处理器状态。每个线程完成独立的任务,但是共享同一片内存空间,打开的文件队列和其他内核资源。

    区别:
    1.一个线程只能属于一个进程,但一个进程可以拥有多个线程,至少有一个线程,线程依赖于进程存在。
    2.进程在运行过程中拥有独立的内存单元,而多个线程共享进程的内存。同一进程中的多个线程共享代码段,数据段,堆区,但是每个线程拥有自己的栈,用来存放临时变量。
    3.进程是操作系统的最小分配单位,线程是最小调度单位。
    4.系统开销:在操作系统进行创建和撤销进程时,需要分配或者回收内存资源,显著的大于线程;在进行进程切换的时候,需要保存当前整个cpu运行环境和创建新的cpu设置,而线程只需要保存少量寄存器内容。
    5.通信:同一进程中的多个线程具有相同的地址空间,因此通信比较容易,比如通过直接读取数据段来进行通信,不过需要进程同步和互斥来保证数据的一致性。
    6.进程不会相互影响,一个线程崩掉,整个进程都会崩。
    7.进程用于多内核,多机分布;线程用于多内核。
    8.进程调试简单方便,但创建撤销开销大;线程调试复杂但开销小,切换速度快。

    进程间通信方式:管道,系统进程通信和套接字
    1.管道可以用于具有亲缘关系的父子进程通信,命名管道还可以用于无亲缘关系的进程间通信。
    普通管道:半双工,具有固定的读端和写端;具有亲缘关系的进程通信;可以被看做是文件,可以使用read和write来读写,但不属于任何文件系统,只是在内核中开辟的一处空间。命名管道有路径名与之关联,属于文件系统;可以用于无亲缘关系的进程通信,它不需要序列化和反序列化,效率比tcp要高,但是比共享内存低。

    2.系统进程通信
    2.1消息队列
    消息队列是消息的链接表,存放于内核中,一个消息队列由消息标识符来标记。具有读权限的进程可以按照一定规则向队列里写信息,具有读权限的进程可以从消息队列读取信息。消息队列克服了信息传输量少,管道只能承载无格式字节流和缓冲区大小受限的缺点。
    1.消息队列是面向记录的,其中的消息具有特定的格式和特定的优先级
    2.消息队里独立于接收和发送进程,进程终止时,消息队列不会被删除
    3.消息队列支持随机读取信息,不需要按先进先出的次序读
    2.2信号量
    信号量是一个计数器,可以用来控制多个进程对共享资源的访问,信号量用来处理进程间的同步和互斥,而不是用来存储通信数据。
    1.信号量用于进程间的同步,如果要存储数据需要结合共享内存。
    2.每次对信号量的PV操作不仅加减1,可以是任意正数
    2.3信号
    用于通知接收进程某个时间已发生
    2.4共享内存
    多个进程可以访问同一块内存空间,不同进程可以及时看到对方进程对共享内存中数据的更新,这种方式依赖于同步操作,比如互斥棒和信号量。
    1.共享内存是速度最快的一种进程通信,因为进程直接对内存访问。
    2.多个进程可以同时操作,所以需要同步
    3.共享内存通常和信号量同时使用,用来处理同步

    3.socket
    socket套接字可以用于不同主机之间的进程通信

    线程间通信方式:
    临界区:通过多线程的串行化来访问公共区域
    互斥量:采用互斥对象机制。只有拥有互斥对象的线程才有访问公共资源的权限,只有就可以保证公共资源不会被多个线程同时使用。
    信号量:允许多个线程同时去访问同一个资源,一般会有最大线程数;
    事件(信号):通过通知的方式来实现多线程同步,还可以方便的实现多线程优先级比较操作。

    如果只有进程,可以实现并发、并行操作,但是会出现以下问题:
    1.同一时间只能干一件事
    2.如果阻塞,整个进程就会被挂起
    引入线程,提高了进程的并发性。同时一个进程的不同线程也可以运行在不同的核上,提高了cpu的利用率。一个完整的任务可以拆分为几个独立的子任务,有助于改善程序结构。
    并发是指宏观上两个进程在同时运行,但微观上看,是两个进程指令交替运行,每个周期实际上只在运行一条指令,提高了效率
    并行是由多核,一个周期确实有多条指令在各自核上运行,互不影响

    更多相关内容
  • 一、对比进程线程1)两者概念- 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.- 线程是指进程内的一个执行单元,也是进程内的可调度实体. 线程是CPU...

    在平时工作中,经常会听到应用程序的进程和线程的概念,那么它们两个之间究竟有什么关系或不同呢?

    一、对比进程和线程

    1)两者概念

    -  进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

    -  线程是指进程内的一个执行单元,也是进程内的可调度实体. 线程是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

    2)两者关系

    -  一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

    -  相对进程而言,线程是一个更加接近于执行体的概念,它可以与同进程中的其他线程共享数据,但拥有自己的栈空间,拥有独立的执行序列。

    3)两者区别

    -  进程和线程的主要差别在于它们是不同的操作系统资源管理方式:进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响;而线程只是一个进程中的不同执行路径。

    -  线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,耗费资源较大,效率要差一些. 但对于一些要求同时进行并且又要共享某些变量的并发操作,只能用线程,不能用进程。

    进程和线程的区别

    - 地址空间:线程是进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;

    - 资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源

    - 线程是处理器调度的基本单位,但进程不是.

    -进程和线程二者均可并发执行.

    -简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

    -  线程的划分尺度小于进程,使得多线程程序的并发性高。

    -另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率。

    -  线程在执行过程中与进程是有区别的。每个独立的线程有一个程序运行入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。

    -从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

    4)优缺点

    线程和进程在使用上各有优缺点:

    - 线程执行开销小,但不利于资源的管理和保护;而进程正相反。

    -  线程适合于在SMP机器上(即对称多处理结构的简称,是指在一个计算机上汇集了一组处理器(多CPU),各CPU之间共享内存子系统以及总线结构)运行,而进程则可以跨机器迁移。

    二、如何查看某个进程的线程数

    有些时候需要确定进程内部当前运行了多少线程,查询方法如下:

    1)通过pstree命令(根据pid)进行查询:

    [root@xqsj_web2 ~]# ps -ef|grep java //查找进程pid(比如这里查找java(tomcat)进程的pid)

    [root@xqsj_web2 ~]# pstree -p 19135

    java(19135)─┬─{java}(19136)

    ├─{java}(19137)

    .......

    └─{java}(13578)

    [root@xqsj_web2 ~]# pstree -p 19135|wc -l

    46 //由于第一行包括了2个线程,所以该进程下一共有47个线程!

    或者使用top命令查看(可以查看到线程情况)

    [root@xqsj_web2 ~]# top -Hp 19135 //下面结果中的Tasks 对应的47即是线程的个数

    top - 14:05:55 up 391 days, 20:59, 1 user, load average: 0.00, 0.00, 0.00

    Tasks: 47 total, 0 running, 47 sleeping, 0 stopped, 0 zombie

    Cpu(s): 0.2%us, 0.1%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st

    Mem: 8058056k total, 7718656k used, 339400k free, 354216k buffers

    Swap: 0k total, 0k used, 0k free, 4678160k cached

    PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

    19135 root 20 0 5339m 632m 5476 S 0.0 8.0 0:00.00 java

    19136 root 20 0 5339m 632m 5476 S 0.0 8.0 0:00.84 java

    ......

    2)根据ps命令直接查询:

    [root@xqsj_web2 ~]# ps hH p 19135| wc -l

    47

    3)通过查看/proc/pid/status

    proc伪文件系统,它驻留在/proc目录,这是最简单的方法来查看任何活动进程的线程数。/proc目录以可读文本文件形式输出,提供现有进程和系统硬件

    相关的信息如CPU、中断、内存、磁盘等等。

    [root@xqsj_web2 ~]# cat /proc/19135/status

    Name: java

    State: S (sleeping)

    Tgid: 19135

    Pid: 19135

    PPid: 1

    TracerPid: 0

    ........

    Threads: 47 //这里显示的是进程创建的总线程数。输出表明该进程有47个线程。

    SigQ: 1/62793

    SigPnd: 0000000000000000

    ShdPnd: 0000000000000000

    .......

    voluntary_ctxt_switches: 1

    nonvoluntary_ctxt_switches: 1

    或者,也可以在/proc//task中简单的统计子目录的数量,如下所示:

    [root@xqsj_web2 ~]# ll /proc/19135/task

    总用量 0

    dr-xr-xr-x 6 root root 0 6月 14 17:57 11553

    ......

    [root@xqsj_web2 ~]# ll /proc/19135/task|wc -l

    48

    这是因为,对于一个进程中创建的每个线程,在/proc//task中会创建一个相应的目录,命名为其线程ID。由此在/proc//task中目录的总数表示在进程中线程的数目。

    比如某台服务器的CPU使用率飙升,通过top命令查看是gitlab程序占用的cpu比较大,"ps -ef|grep gitlab"发现有很多个gitlab程序,现在需要查询gitlab各个进程下的线程数情况。批量查询命令如下:

    # for pid in $(ps -ef|grep -v grep|grep gitlab|awk '{print $2}');do echo ${pid} > /root/a.txt ;cat /proc/${pid}/status|grep Threads > /root/b.txt;paste /root/a.txt /root/b.txt;done|sort -k3 -rn

    脚本解释:

    1)for pid in $(ps -ef|grep -v grep|grep gitlab|awk '{print $2}')

    定义${pid}变量为gitlab进程的pid号

    2)echo ${pid} > /root/a.txt

    将http进程的pid号都打印到/root/a.txt文件中

    3)cat /proc/${pid}/status|grep Threads > /root/b.txt

    将各个pid进程号下的线程信息打印到/root/b.txt文件中

    4)paste /root/a.txt /root/b.txt

    以列的形式展示a.txt和b/txt文件中的信息

    5)sort -k3 -rn

    -k3 表示以第三列进行排序

    -rn 表示降序

    e93e8a474f3654c5b69da954066e188a.png

    来看个cup使用率告警问题处理案例

    收到告警,生产环境一台机器的cpu使用率超过了85%!立刻登录服务器,发现情况如下:

    [root@kevin ~]# uptime

    10:39:40 up 215 days, 13:02, 2 users, load average: 3.32, 3.40, 3.37

    [root@kevin ~]# top

    top - 10:52:51 up 215 days, 13:15, 3 users, load average: 3.32, 3.40, 3.37

    Tasks: 168 total, 1 running, 167 sleeping, 0 stopped, 0 zombie

    Cpu(s): 98.4%us, 0.2%sy, 0.0%ni, 1.3%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st

    Mem: 8053692k total, 6542296k used, 1511396k free, 168560k buffers

    Swap: 16777212k total, 0k used, 16777212k free, 2565452k cached

    PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

    31969 app 20 0 4510m 1.9g 6220 S 393.5 25.1 2281:49 java

    .........

    [root@kevin ~]# ps -ef|grep 31969

    root 15826 15129 0 10:58 pts/0 00:00:00 grep 31969

    app 31969 31962 0 Jul02 ? 02:25:01 java -cp /data/lo-boxes/box_home/lo-starter.jar:/data/lo-boxes/box_home/lib/* -Dbox.name=B0002 -Dbox.home=/data/lo-boxes/B0002 -Dbox.jmx.port=57009 -XX:+CMSPermGenSweepingEnabled -XX:SoftRefLRUPolicyMSPerMB=1 -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=60 -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseParNewGC -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=1 -XX:+CMSClassUnloadingEnabled -XX:MaxTenuringThreshold=12 -XX:SurvivorRatio=8 -XX:ParallelGCThreads=3 -XX:+HeapDumpOnOutOfMemoryError -Dsun.reflect.inflationThreshold=2147483647 -XX:HeapDumpPath=/data/lo-boxes/B0002/boxlogs/logs/heapdump_31961.hprof -Xloggc:/data/lo-boxes/B0002/boxlogs/gclogs/gc.31961.log -XX:ErrorFile=/data/lo-boxes/B0002/boxlogs/hs_err_pid31961.log -Xms1024M -Xmx1024M -XX:PermSize=256M -XX:MaxPermSize=256M -XX:NewSize=256M -XX:MaxNewSize=512M cn.openlo.starter.BoxStartupStandalone

    解决办法:

    1)最简单粗暴的方法:重启上面这个pid号为31969的进程所属的服务程序

    2)查出这个pid进程的cpu资源各自被哪个线程所占。通过"top -Hp pid"可以查看该进程下各个线程的cpu使用情况;如下:

    [root@kevin ~]# top -Hp 31969

    .......

    PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

    31969 app 20 0 3754m 1714m 16m S 390.5 29.1 0:00.00 java

    31970 app 20 0 3754m 2124m 16m S 382.2 20.5 0:02.74 java

    31971 app 20 0 3754m 1954m 16m S 360.0 19.5 0:00.49 java

    31972 app 20 0 3754m 1584m 16m S 300.9 23.1 0:00.48 java

    ......

    如上可知,31969的进程主要被上面四个线程耗了过多的CPU资源。

    通过top命令定位到cpu占用率较高的线程之后,继续使用jstack pid命令查看当前java进程的堆栈状态,这就用到jstack工具!

    jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息。

    jstack可以定位到线程堆栈,根据堆栈信息我们可以定位到具体代码,所以它在JVM性能调优中使用得非常多。

    jstack工具一般是在java/bin目录下的。如下设置java环境变量

    =============================================================================================

    [root@kevin ~]# ll /data/software/

    总用量 626244

    drwxr-xr-x 8 app app 4096 4月 11 2015 jdk1.7.0_80

    -rw-r--r-- 1 app app 153530841 6月 4 2016 jdk-7u80-linux-x64.tar.gz

    [root@kevin ~]# /data/software/jdk1.7.0_80/bin/java -version

    java version "1.7.0_80"

    Java(TM) SE Runtime Environment (build 1.7.0_80-b15)

    Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

    [root@kevin ~]# vim /etc/profile

    JAVA_HOME=/data/software/jdk1.7.0_80

    JAVA_BIN=/data/software/jdk1.7.0_80/bin

    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/bin:/sbin/:/data/software/jdk1.7.0_80/bin/

    CLASSPATH=.:/lib/dt.jar:/lib/tools.jar

    export JAVA_HOME JAVA_BIN PATH CLASSPATH

    [root@kevin ~]# source /etc/profile

    [root@kevin ~]# mv /usr/bin/java /usr/bin/java.bak

    [root@kevin ~]# ln -s /data/software/jdk1.7.0_80/bin/java /usr/bin/java

    [root@kevin ~]# java -version

    java version "1.7.0_80"

    Java(TM) SE Runtime Environment (build 1.7.0_80-b15)

    Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)

    [root@kevin ~]# jstack --help

    Usage:

    jstack [-l]

    (to connect to running process)

    jstack -F [-m] [-l]

    (to connect to a hung process)

    jstack [-m] [-l]

    (to connect to a core file)

    jstack [-m] [-l] [server_id@]

    (to connect to a remote debug server)

    Options:

    -F to force a thread dump. Use when jstack does not respond (process is hung)

    -m to print both java and native frames (mixed mode)

    -l long listing. Prints additional information about locks

    -h or -help to print this help message

    =============================================================================================

    下面开始使用jstack对

    [root@kevin ~]# jstack 31969 或者"jstack 31969 > jstack-31969" 打印出堆栈信息到一个文件中,方便后续查看

    [root@kevin ~]# jstack 31970

    [root@kevin ~]# jstack 31971

    [root@kevin ~]# jstack 31972

    d779509a7a526ad8bc358aede44e483a.png

    jstack命令生成的thread dump信息包含了JVM中所有存活的线程,为了分析指定线程,必须找出对应线程的调用栈,应该如何找?

    在top命令中,已经获取到了占用cpu资源较高的线程pid,将该pid转成16进制的值,在thread dump中每个线程都有一个nid,找到对应的nid即可;隔段时间再执行一次stack命令获取thread dump,区分两份dump是否有差别,在nid=0x246c的线程调用栈中,发现该线程一直在执行JstackCase类第33行的calculate方法,得到这个信息,就可以检查对应的代码是否有问题。

    获取进程pid的方法

    [root@ansible-server ~]# ps -ef|grep nginx

    root 2148 1 0 2018 ? 00:00:00 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf

    root 16517 16179 0 11:09 pts/1 00:00:00 grep nginx

    nginx 21091 2148 0 Jan27 ? 00:00:00 nginx: worker process

    使用"ps x"

    [root@ansible-server ~]# ps x | grep nginx

    2148 ? Ss 0:00 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf

    16526 pts/1 S+ 0:00 grep nginx

    [root@ansible-server ~]# ps x | grep nginx|grep -v grep|awk '{print $1}'

    2148

    使用"pgrep"

    [root@ansible-server ~]# pgrep nginx

    2148

    21091

    [root@ansible-server ~]# pgrep -f nginx

    2148

    21091

    使用pidof

    [root@ansible-server ~]# pidof nginx

    21091 2148

    使用pstree

    [root@ansible-server ~]# pstree -p | grep nginx

    |-nginx(2148)---nginx(21091)

    展开全文
  • Android一个APP里面最少有几个线程

    千次阅读 2021-06-04 10:48:22
    参考线程查看Android一个进程里面最少包含5个线程,分别为:main线程(主线程)FinalizerDaemon线程终结者守护线程。对于重写了成员函数finalize的对象,它们被GC决定回收时,并没有马上被回收,而是被放入到一个队列...

    参考

    线程查看

    Android一个进程里面最少包含5个线程,分别为:

    main线程(主线程)

    FinalizerDaemon线程

    终结者守护线程。对于重写了成员函数finalize的对象,它们被GC决定回收时,并没有马上被回收,而是被放入到一个队列中,等待FinalizerDaemon守护线程去调用它们的成员函数finalize,然后再被回收。

    FinalizerWatchdogDaemon线程

    监控终结者守护线程。用来监控FinalizerDaemon线程的执行。一旦检测那些重定了成员函数finalize的对象在执行成员函数finalize时超出一定的时候,那么就会退出VM。

    HeapTaskDaemon线程

    堆栈守护线程。用来执行堆栈的操作,也就是用来将那些空闲的堆内存归还给系统。

    ReferenceQueueDaemon线程。

    引用队列守护线程。我们知道,在创建引用对象的时候,可以关联一个队列。当被引用对象引用的对象被GC回收的时候,被引用对象就会被加入到其创建时关联的队列去。这个加入队列的操作就是由ReferenceQueueDaemon守护线程来完成的。这样应用程序就可以知道哪些被引用对象引用的对象已经被回收了。

    下图是创建的一个仅有hello World!页面的工程,线程包含以下的这些。

    a078bc1623b9

    image.png

    刚开始我比较疑惑的是FileObserver 这个线程是否也是每个进程所必须包含的线程。后来我查看了一下Daemons创建的过程,能确定的是Android启动一个APP最少包含ReferenceQueueDaemon线程、FinalizerDaemon线程、FinalizerWatchdogDaemon线程、HeapTaskDaemon线程,以及在ActivityThread中开启的主线程。如下:

    public final class Daemons {

    private static final int NANOS_PER_MILLI = 1000 * 1000;

    private static final int NANOS_PER_SECOND = NANOS_PER_MILLI * 1000;

    private static final long MAX_FINALIZE_NANOS = 10L * NANOS_PER_SECOND;

    public static void start() {

    ReferenceQueueDaemon.INSTANCE.start();//开启ReferenceQueueDaemon线程

    FinalizerDaemon.INSTANCE.start();//开启FinalizerDaemon线程

    FinalizerWatchdogDaemon.INSTANCE.start();//开启FinalizerWatchdogDaemon线程

    HeapTaskDaemon.INSTANCE.start();//开启HeapTaskDaemon线程

    }

    public static void startPostZygoteFork() {

    ReferenceQueueDaemon.INSTANCE.startPostZygoteFork();

    FinalizerDaemon.INSTANCE.startPostZygoteFork();

    FinalizerWatchdogDaemon.INSTANCE.startPostZygoteFork();

    HeapTaskDaemon.INSTANCE.startPostZygoteFork();

    }

    public static void stop() {

    HeapTaskDaemon.INSTANCE.stop();

    ReferenceQueueDaemon.INSTANCE.stop();

    FinalizerDaemon.INSTANCE.stop();

    FinalizerWatchdogDaemon.INSTANCE.stop();

    }

    ...

    }

    1.main线程

    2. ReferenceQueueDaemon线程。

    代码块

    3. FinalizerDaemon线程

    private static class FinalizerDaemon extends Daemon {

    private static final FinalizerDaemon INSTANCE = new FinalizerDaemon();

    private final ReferenceQueue queue = FinalizerReference.queue;

    private final AtomicInteger progressCounter = new AtomicInteger(0);

    // Object (not reference!) being finalized. Accesses may race!

    private Object finalizingObject = null;

    FinalizerDaemon() {

    super("FinalizerDaemon");

    }

    @Override public void runInternal() {

    // This loop may be performance critical, since we need to keep up with mutator

    // generation of finalizable objects.

    // We minimize the amount of work we do per finalizable object. For example, we avoid

    // reading the current time here, since that involves a kernel call per object. We

    // limit fast path communication with FinalizerWatchDogDaemon to what's unavoidable: A

    // non-volatile store to communicate the current finalizable object, e.g. for

    // reporting, and a release store (lazySet) to a counter.

    // We do stop the FinalizerWatchDogDaemon if we have nothing to do for a

    // potentially extended period. This prevents the device from waking up regularly

    // during idle times.

    // Local copy of progressCounter; saves a fence per increment on ARM and MIPS.

    int localProgressCounter = progressCounter.get();

    while (isRunning()) {

    try {

    // Use non-blocking poll to avoid FinalizerWatchdogDaemon communication

    // when busy.

    FinalizerReference> finalizingReference = (FinalizerReference>)queue.poll();

    if (finalizingReference != null) {

    finalizingObject = finalizingReference.get();

    progressCounter.lazySet(++localProgressCounter);

    } else {

    finalizingObject = null;

    progressCounter.lazySet(++localProgressCounter);

    // Slow path; block.

    FinalizerWatchdogDaemon.INSTANCE.goToSleep();

    finalizingReference = (FinalizerReference>)queue.remove();

    finalizingObject = finalizingReference.get();

    progressCounter.set(++localProgressCounter);

    FinalizerWatchdogDaemon.INSTANCE.wakeUp();

    }

    doFinalize(finalizingReference);

    } catch (InterruptedException ignored) {

    } catch (OutOfMemoryError ignored) {

    }

    }

    }

    @FindBugsSuppressWarnings("FI_EXPLICIT_INVOCATION")

    private void doFinalize(FinalizerReference> reference) {

    FinalizerReference.remove(reference);

    Object object = reference.get();

    reference.clear();

    try {

    object.finalize();

    } catch (Throwable ex) {

    // The RI silently swallows these, but Android has always logged.

    System.logE("Uncaught exception thrown by finalizer", ex);

    } finally {

    // Done finalizing, stop holding the object as live.

    finalizingObject = null;

    }

    }

    }

    4. FinalizerWatchdogDaemon线程

    代码块

    5. HeapTaskDaemon线程

    private static class HeapTaskDaemon extends Daemon {

    private static final HeapTaskDaemon INSTANCE = new HeapTaskDaemon();

    HeapTaskDaemon() {

    super("HeapTaskDaemon");

    }

    // Overrides the Daemon.interupt method which is called from Daemons.stop.

    public synchronized void interrupt(Thread thread) {

    VMRuntime.getRuntime().stopHeapTaskProcessor();

    }

    @Override public void runInternal() {

    synchronized (this) {

    if (isRunning()) {

    // Needs to be synchronized or else we there is a race condition where we start

    // the thread, call stopHeapTaskProcessor before we start the heap task

    // processor, resulting in a deadlock since startHeapTaskProcessor restarts it

    // while the other thread is waiting in Daemons.stop().

    VMRuntime.getRuntime().startHeapTaskProcessor();

    }

    }

    // This runs tasks until we are stopped and there is no more pending task.

    VMRuntime.getRuntime().runHeapTasks();

    }

    }

    查看VMRuntime的源码发现 startHeapTaskProcessor()、runHeapTasks()均是native方法。

    public native void requestConcurrentGC();

    public native void concurrentGC();

    public native void requestHeapTrim();

    public native void trimHeap();

    public native void startHeapTaskProcessor();

    public native void stopHeapTaskProcessor();

    public native void runHeapTasks();

    如何查看当前项目包含几个线程

    在Android studio中点击Profile 图标,点击 CPU,显示如下图,点击 Record,然后再点击 Stop,即可生成。

    a078bc1623b9

    image.png

    展开全文
  • 进程线程的区别(超详细)

    万次阅读 多人点赞 2019-10-03 21:57:46
    进程和线程 进程 一个在内存中运行的应用...一个进程至少一个线程一个进程可以运行多个线程,多个线程可共享数据。 与进程不同的是同类的多个线程共享进程的堆和方法区资源,但每个线程有自己的程序计数器、虚拟...

    进程和线程

    进程

    一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程,比如在Windows系统中,一个运行的xx.exe就是一个进程。

    任务管理器

    线程

    进程中的一个执行任务(控制单元),负责当前进程中程序的执行。一个进程至少有一个线程,一个进程可以运行多个线程,多个线程可共享数据。

    与进程不同的是同类的多个线程共享进程的方法区资源,但每个线程有自己的程序计数器虚拟机栈本地方法栈,所以系统在产生一个线程,或是在各个线程之间作切换工作时,负担要比进程小得多,也正因为如此,线程也被称为轻量级进程。

    Java 程序天生就是多线程程序,我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程,代码如下。

    public class MultiThread {
    	public static void main(String[] args) {
    		// 获取 Java 线程管理 MXBean
    		ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    		// 不需要获取同步的 monitor 和 synchronizer 信息,仅获取线程和线程堆栈信息
    		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
    		// 遍历线程信息,仅打印线程 ID 和线程名称信息
    		for (ThreadInfo threadInfo : threadInfos) {
    			System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
    		}
    	}
    }
    

    上述程序输出如下(输出内容可能不同,不用太纠结下面每个线程的作用,只用知道 main 线程执行 main 方法即可):

    [6] Monitor Ctrl-Break //监听线程转储或“线程堆栈跟踪”的线程
    [5] Attach Listener //负责接收到外部的命令,而对该命令进行执行的并且把结果返回给发送者
    [4] Signal Dispatcher // 分发处理给 JVM 信号的线程
    [3] Finalizer //在垃圾收集前,调用对象 finalize 方法的线程
    [2] Reference Handler //用于处理引用对象本身(软引用、弱引用、虚引用)的垃圾回收的线程
    [1] main //main 线程,程序入口
    

    从上面的输出内容可以看出:一个 Java 程序的运行是 main 线程和多个其他线程同时运行

    进程与线程的区别总结

    线程具有许多传统进程所具有的特征,故又称为轻型进程(Light—Weight Process)或进程元;而把传统的进程称为重型进程(Heavy—Weight Process),它相当于只有一个线程的任务。在引入了线程的操作系统中,通常一个进程都有若干个线程,至少包含一个线程。

    根本区别:进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位

    资源开销:每个进程都有独立的代码和数据空间(程序上下文),程序之间的切换会有较大的开销;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小。

    包含关系:如果一个进程内有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的;线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程。

    内存分配:同一进程的线程共享本进程的地址空间和资源,而进程之间的地址空间和资源是相互独立的

    影响关系:一个进程崩溃后,在保护模式下不会对其他进程产生影响,但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

    执行过程:每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制,两者均可并发执行

    从 JVM 角度说进程和线程之间的关系(重要)

    图解进程和线程的关系

    下图是 Java 内存区域,通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。

    在这里插入图片描述

    从上图可以看出:一个进程中可以有多个线程,多个线程共享进程的方法区 (JDK1.8 之后的元空间)资源,但是每个线程有自己的程序计数器虚拟机栈本地方法栈

    程序计数器为什么是私有的?

    程序计数器主要有下面两个作用:

    1. 字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行、选择、循环、异常处理。
    2. 在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。

    需要注意的是,如果执行的是 native 方法,那么程序计数器记录的是 undefined 地址,只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。

    所以,程序计数器私有主要是为了线程切换后能恢复到正确的执行位置

    虚拟机栈和本地方法栈为什么是私有的?

    • 虚拟机栈:每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程,就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
    • 本地方法栈:和虚拟机栈所发挥的作用非常相似,区别是: 虚拟机栈为虚拟机执行 Java 方法 (也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。

    所以,为了保证线程中的局部变量不被别的线程访问到,虚拟机栈和本地方法栈是线程私有的。

    一句话简单了解堆和方法区

    堆和方法区是所有线程共享的资源,其中堆是进程中最大的一块内存,主要用于存放新创建的对象 (所有对象都在这里分配内存),方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

    多进程和多线程区别

    多进程:操作系统中同时运行的多个程序

    多线程:在同一个进程中同时运行的多个任务

    举个例子,多线程下载软件,可以同时运行多个线程,但是通过程序运行的结果发现,每一次结果都不一致。 因为多线程存在一个特性:随机性。造成的原因:CPU在瞬间不断切换去处理各个线程而导致的,可以理解成多个线程在抢CPU资源。

    多线程提高CPU使用率

    多线程

    多线程并不能提高运行速度,但可以提高运行效率,让CPU的使用率更高。但是如果多线程有安全问题或出现频繁的上下文切换时,运算速度可能反而更低。

    Java中的多线程

    Java程序的进程里有几个线程:主线程,垃圾回收线程(后台线程)等

    在 Java 中,当我们启动 main 函数时其实就是启动了一个 JVM 的进程,而 main 函数所在的线程就是这个进程中的一个线程,也称主线程。

    Java支持多线程,当Java程序执行main方法的时候,就是在执行一个名字叫做main的线程,可以在main方法执行时,开启多个线程A,B,C,多个线程 main,A,B,C同时执行,相互抢夺CPU,Thread类是java.lang包下的一个常用类,每一个Thread类的对象,就代表一个处于某种状态的线程

    展开全文
  • 1. 什么是进程线程 现代操作系统比如Mac OS X,UNIX,Linux,Windows等,都是支持“多任务”的操作系统。 1.1 百科解释 进程(Process)是计算机中的程序关于某数据集合上的次运行活动,是系统进行资源分配和...
  • 进程线程、协程

    2022-03-20 15:17:54
    一个进程至少包含一个主线程,也可以有更多的子线程线程拥有自己的栈空间。 协程 协程,英文Coroutines,是一种比线程更加轻量级的存在。正如一个进程可以拥有多个线程一样,一个线程也可以拥有多个协程。 最重要...
  • 计算机操作系统之进程线程

    多人点赞 热门讨论 2022-03-22 23:23:59
    本篇文章将介绍计算机操作系统的相关内容,主要内容有进程进程调度,并行与并发的概念,进程间通信,进程线程的区别。
  • Java之进程线程

    2021-06-03 09:50:10
    深入理解进程线程 ...进程线程一个进程可以包括多个线程线程间内存共享:一个车间的空间是工人们共享的,比如许多房间是每个工人都可以进出的。 同理一个进程的内存空间是共享的,里面的每个线..
  • 线程进程,你真得理解了吗

    万次阅读 多人点赞 2022-05-06 19:05:25
    相信大家面试时一定没少被一个问题刁难,那就是进程线程的区别是什么?这个问题延申开来并不像表面那么简单,今天就来深入一探。 开始前先看一组非常传神的图例,相信可以帮助你更好理解进程线程的概念: 1 ...
  • 进程线程的概念、区别及进程线程间通信

    千次阅读 多人点赞 2020-08-02 16:24:25
    每个线程都独自占用一个虚拟处理器:独自的寄存器组,指令计数器和处理器状态。每个线程完成不同的任务,但是共享同一地址空间(也就是同样的动态内存,映射文件,目标代码等等),打开的文件队列和其他
  • 程序,进程线程的区别和联系

    万次阅读 多人点赞 2018-08-26 22:27:18
    进程一个动态的实体,它有自己的生命周期。它因创建而产生,因调度而运行,因等待资源或事件而被处于等待状态,因完成任务而被撤消。反映了一个程序在一定的数据集上运行的全部动态过程。 2)进程和程序并不是一一...
  • 如果你使用谷歌浏览器打开一个网页为什么至少会有4个进程呢 2007年之前早期的浏览器都是单进程的,但是这会有一个特别大的问题,我们都知道一个进程可以有多个线程,每个线程可以读取公共进程中的数据,如下图 早期...
  • 线程进程一--并发和并行

    千次阅读 2022-03-20 11:25:04
    并行,parallel:同一个时间点,不同任务同时进行,互不干扰。 并发,concurrency:需要同时做某些事,强调的是需要处理多项事务,不一定同时进行。 —> 并行解决的是并发需求的一种方式。 —>队列、缓冲区,...
  • 进程线程详解

    2019-08-12 01:32:58
    线程:单个进程执行中每个任务就是一个线程线程进程中执行运算的最小单位。 区别联系 1、引入线程可提高程序并发执行的程度,可进一步提高系统效率,减少程序并发执行时所付出的时空开销。线程是一种特殊进程,...
  • 了解线程进程之间的数据共享关系,创建一个线程,在线程中更改进程中的数据; 二、 实验内容: 在进程中定义全局共享数据,在线程中直接引用该数据进行更改并输出该数据; 三、实验要求 显示和输出共享数据; ...
  • 进程线程的定义和区别1、进程定义进程:是具有一定独立功能的程序关于某个数据集合上的一次进行活动,是系统进行资源分配和调度的一个独立单位。2、线程定义线程:是进程一个实体,是cpu调度和分派的基本单位,...
  • 进程 线程 协程

    2020-04-07 09:27:39
    进程 线程 协程的关系 ...那线程呐:线程从属于进程,是进程的实际执行者,一个进程至少包含一个主线程这就是为什么你写Java的时候为什么至少要有一个main方法,线程同时也拥有自己的栈空间。 对于操作系统而言,线...
  • 进程线程的区别

    千次阅读 2022-02-25 23:39:54
    2.进程拥有一个完整的资源平台,而线程只独享必不可少的资源,如寄存器和栈; 3.线程同样具有就绪、阻塞、执行三种基本状态,同样具有状态之间的转换关系; 4.线程能减少并发执行的时间和空间开销; 对于,线程相比...
  • CPU核心、进程线程

    2020-05-23 20:45:40
    一个进程至少一个线程一个进程可以运行多个线程,多个线程可共享数据。  与进程不同的是同类的多个线程共享进程的堆和方法区资源,但每个线程有自己的程序计数器、虚拟机栈和本地方法栈,所以系统在产生一个...
  • 进程线程合集以及实例

    千次阅读 2020-10-12 11:34:51
    文章目录进程线程0.1 粗略介绍:0.2 线程进程区别:.进程1.1 fork创建单进程1.2 multiprocessing:Process 创建子进程1.2 multiprocessing:Pool 创建进程池1.3 进程间通信 公共队列二. 线程2.1 多线程的优点:二. ...
  • 并发:指两个或多个事件在同一个时间段内发生 并行:指两个或多个事件在同一时刻发生(同时发生) 在操作系统中,安装了多个程序,并发指的是在一段时间内宏观上有多个程序同时运行,这在单 CPU 系统中,每 一时刻...
  • 进程线程

    万次阅读 多人点赞 2021-03-17 22:50:20
    进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间 动态性 进程与程序的区别在于,程序只是...
  • 进程线程的关系

    千次阅读 2018-05-05 22:42:55
    (1)一个线程只能属于一个进程,而一个进程可以有多个线程,但至少一个线程(2)资源分配给进程进程是程序的主体,同一进程的所有线程共享该进程的所有资源(3)cpu分配给线程,即真正在cpu上运行的是线程(4)...
  • 进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间作切换工作时,负担要比进程小得多,也正因为如此,线程也被称为轻量级进程。 程序
  • 彻底理解 进程线程、多进程、多线程

    多人点赞 热门讨论 2022-03-26 17:15:15
    教科书上解释:进程是资源分配的最小单位。线程是CPU调度的最小单位。
  • 进程线程的深入理解

    万次阅读 多人点赞 2019-04-25 00:14:40
    进程线程的深入理解,从抽象类比到与原理,阐述了两者的区别
  • 通常进程还要包含其他资源,像打开的文件,挂起的信号,内核内部数据,持利器状态,一个或多个具有内存映射的内存地址空间以及一个或多个执行线程,当然还包括用来存放全局变量的数据段等。 然而每一个线程都拥有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 133,720
精华内容 53,488
关键字:

一个进程至少包含一个线程