精华内容
下载资源
问答
  • 关于资源,Java线程的线程栈所占用的内存在Java堆外的,所以不受java程序控制的,只受系统资源限制,默认一个线程的线程栈大小1M(当让这个可以通过设置-Xss属性设置,但是要注意栈溢出问题),但是,如果每个...

    ---->关于时间,创建线程使用是直接向系统申请资源的,这里调用系统函数进行分配资源的话耗时不好说。
    ---->关于资源,Java线程的线程栈所占用的内存是在Java堆外的,所以是不受java程序控制的,只受系统资源限制,默认一个线程的线程栈大小是1M(当让这个可以通过设置-Xss属性设置,但是要注意栈溢出问题),但是,如果每个用户请求都新建线程的话,1024个用户光线程就占用了1个G的内存,如果系统比较大的话,一下子系统资源就不够用了,最后程序就崩溃了。
    --->对操作系统来说,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度,同时在线程切换的时候还要执行内存换页,CPU 的缓存被 清空,切换回来的时候还要重新从内存中读取信息,破坏了数据的局部性。

    展开全文
  • 一个进程都拥有自己数据段,代码段和堆栈段,这就造成进程在进行创建和切换以及撤销等操作时候,需要较大的系统开销。 <2>为了减少系统开销,将进程中演化出了线程 <3>线程存在于进程之中,共享...

    Linux多线程程序设计

    1.线程出现的原因
    <1>每一个进程都拥有自己的数据段,代码段和堆栈段,这就造成进程在进行创建和切换以及撤销等操作的时候,需要较大的系统开销。
    <2>为了减少系统开销,将进程中演化出了线程
    <3>线程存在于进程之中,共享进程的资源
    <4>线程是进程中的独立控制流,由环境和一系列的执行指令组成。
    通过一个图感受一下进程和线程的不同点
    在这里插入图片描述
    2.线程和进程去比较
    <1>传统意义上的进程被称为重量级的进程,从现代的角度来看,就是只拥有一个线程的进程
    <2>线程与进程有着许多类似的性质,包含的关系,所以我们习惯上也称线程为轻量级进程
    3.调度
    <1>线程是CPU调度和分派的基本单位
    <2>进程是系统中程序执行和资源分配的最小单位
    <3>线程本身只拥有一部分必须拥有的资源,除此之外需要的资源都需要去进程中去调用
    4.并发性和并行性
    <1>不仅可以在进程间去进行并发性,在一个进程中的多线程之间也可以去执行并发性。并发性指的是在一个核上也就是只有一个cpu在进行处理的工作,它需要在一个周期内执行完所有的工作,然后一直重复着这个周期的工作,我们的电脑就是,但是由于我们肉眼的感觉,这个软件好像是同时进行的。
    在这里插入图片描述
    <2>并行性指的是一个系统中存在着多个CPU,每一个CPU去执行一个进程。
    5.使用多线程的优点
    <1>在多处理器中开发程序的并行性
    <2>在等待慢速的IO操作的时候,系统可以去执行其他的线程,提高并发性
    <3>模块化的编程,能够更清晰的表达程序中独立事件的关系,结构清晰
    <4>占用较少的资源
    6.获取进程和线程的id
    <1>每一个进程拥有自己的进程号,因此每一个线程也拥有着自己的线程号,但是这里需要注意的是,每一个进程的进程号在整个系统中都是独一无二的,但是每一个线程的线程号只是相对于它所属的进程环境而言的。
    <2>进程号用一个pid_t去表示,他是一个非负整数。线程号则用phread_t数据类型来表示。因为二者都是无符号型所以在输出的时候需要用到%u。获取进程id需要调用getpid(),获取线程id需要phread_self();在调用程序中pthread.h库后,在编译的过程中一定要把这个库添加进来,感觉可以理解它是一个动态库
    在这里插入图片描述
    7.创建一个线程
    创建一个线程用到函数体 int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void *(start_routine)(void),void *arg);
    第一个参数:新进程的id,线程标识符地址
    第二个参数:线程属性结构地址,这里还没学到直接给她一个空
    第三个参数:线程函数的入口地址,填写我们写的函数名
    第四个参数:传给新线程执行函数的参数
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 1、程序建立1000个线程,有可能造成系统创建大量线程而导致消耗完系统内存,还会增加创建和销毁线程上所花的时间以及系统资源的开销2、在创建线程数的情况下,可以考虑使用线程池以下Java自带的几种线程池:(1)...

    1、程序建立1000个线程,有可能造成系统创建大量线程而导致消耗完系统内存,还会增加创建和销毁线程上所花的时间以及系统资源的开销

    2、在创建线程数多的情况下,可以考虑使用线程池

    以下是Java自带的几种线程池:

    (1)、newFixedThreadPool 创建一个指定工作线程数量的线程池。

    每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。

    (2)、newCachedThreadPool 创建一个可缓存的线程池。

    这种类型的线程池特点是:

    1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

    2).如果长时间没有往线程池中提交任务,即如果工作线程空闲了指定的时间(默认为1分钟),则该工作线程将自动终止。终止后,如果你又提交了新的任务,则线程池重新创建一个工作线程。

    (3)、newSingleThreadExecutor 创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,如果这个线程异常结束,会有另一个取代它,保证顺序执行(我觉得这点是它的特色)。

    单工作线程最大的特点是可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的 。

    (4)、newScheduleThreadPool 创建一个定长的线程池,而且支持定时的以及周期性的任务执行,类似于Timer。

    3、示例代码

    package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExecutorTest { public static void main(String[] args) { ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 1000; i++) { cachedThreadPool.execute(new Runnable() { public void run() { //在这里执行你需要的功能 } }); } } }

    取消

    评论

    展开全文
  • 一、 线程与进程的比较:1.1 线程与进程:线程:线程进程中的一个单位线程计算机中被CPU调度的最小单位,开销小轻型进程 轻量级的进程在同一个进程中的多个线程是可以共享公有数据线程的开启\销毁\切换都比进程...

    一、 线程与进程的比较:

    1.1 线程与进程:

    线程:

    线程是进程中的一个单位

    线程是计算机中被CPU调度的最小单位,开销小

    轻型进程 轻量级的进程

    在同一个进程中的多个线程是可以共享公有数据

    线程的开启\销毁\切换都比进程要高效很多

    进程:

    计算机中最小的资源分配单位

    数据隔离 开销大

    1.2 为什么要使用线程:

    开启进程 关闭进程 切换进程都需要时间

    你的电脑的资源还是有限的

    开启过多的进程会导致你的计算机崩溃

    多个进程与多个线程都可以利用多核(多个CPU)处理数据

    1.3  python当中的多线程:

    不能访问多个cpu,是Cpython解释器导致

    Cpython解释器存在全局解释器锁(GIL-Global Interpreter Lock),导致了同一时刻只能有一个线程访问CPU

    jpython pypy解释器中的多线程是可以访问多核(多个CPU)

    二、 dis模块:

    查看Python解释器运行的底层代码块对应的字节码指令序列

    示例:

    #示例:

    from dis importdisdeffunc():

    a=[]

    a.append(1)

    dis(func)

    View Code

    三、 创建线程:

    #示例(无参数):

    importosimporttimefrom threading importThreaddeffunc():

    time.sleep(1)print('in func', os.getpid())print('in main', os.getpid())for i in range(10):

    Thread(target=func).start() #创建10个线程

    无参数创建

    #示例(参数):#创建10个子线程:

    importosimporttimefrom threading importThreaddef func(i): #子线程函数

    time.sleep(1)print('in func', i, os.getpid())print('in main', os.getpid())for i in range(20):

    Thread(target=func, args=(i,)).start() #i通过args参数传递到自线程

    带参数实现

    四、 进程与线程之间的内存开销比较:

    主线程是在进程中创建多个子线程,开销小

    主进程会创建多个子进程,开销大

    #线程与进程之间的开销:

    importtimefrom multiprocessing importProcessfrom threading importThreaddeffunc(a):

    a+= 1

    if __name__ == '__main__':

    t_start= time.time() #线程的开启时间

    t_l =[]for i in range(100):

    t= Thread(target=func, args=(i,))

    t.start()

    t_l.append(t)for t int_l:

    t.join()print('thread :', time.time() - t_start) #线程的时间差 thread : 0.03014397621154785

    p_start= time.time() #进程的开启时间

    p_l =[]for i in range(100):

    p= Process(target=func, args=(i,))

    p.start()

    p_l.append(t)for p inp_l:

    t.join()print('Process', time.time() - p_start) #进程的时间差 Process 2.994523525238037

    View Code

    五、 进程与线程在内存中的数据分配:

    线程之间共有数据共享

    进程中数据都是私有,不共享

    #线程与线程和进程与进程之间数据使用比较:

    #多个线程之间的全局变量是共享的:

    from threading importThread

    tn= 0 #全局变量

    deffunc():globaltn

    tn+= 1t_l=[]for i in range(100):

    t= Thread(target=func)

    t.start()

    t_l.append(t)for t int_l:

    t.join()print("Thread:", tn) #Thread: 100

    #进程之间数据隔离:#进程之间的数据不能共享,在子进程中数据的修改不能改变全局变量的值(可以通过Manager类修改)

    from multiprocessing importProcess

    pn= 0 #全局变量

    deffunc():globalpn

    pn+= 1

    if __name__ == '__main__':

    p_l=[]for i in range(100):

    p= Process(target=func)

    p.start()

    p_l.append(p)for p inp_l:

    p.join()print("Process:", pn) #Process: 0

    View Code

    六、 线程的其他方法:

    6.1 active_count类:

    线程没有terminate 不能强制结束,主线程等待直到子线程结束

    active_count(): 查看当前正在工作的线程个数

    #示例:

    importosimporttimefrom threading importThread, active_countdeffunc():

    time.sleep(2)print('in func', os.getpid())for i in range(10):

    Thread(target=func).start()print(active_count()) #11

    View Code

    6. 2  currentThread, activeCount, enumerate类方法:

    #currentThread类:#currentThread().name :查看线程名#currentThread().ident :查看线程号

    #示例:

    importosfrom threading importThread, currentThread, activeCount, enumeratedeffunc():

    t=currentThread()print(t.getName()) #查看线程名:Thread-1

    t.setName('AAA') #设置线程名:AAA

    print(t.name, t.ident, os.getpid()) #Thread-1 7832 1960 (子线程)

    tobj= Thread(target=func)

    tobj.start()print('tobj :', tobj) #tobj :

    t2 =currentThread()print(t2.name, t2.ident, os.getpid()) #MainThread 17672 1960 (主线程)

    print('主线程...')print(t2.is_alive()) #查看线程是否还存活

    print(activeCount()) #返回正在运行的线程数量, 与len(threading.enumerate())有相同的结果

    print(enumerate()) #返回一个正在运行的所有线程的列表

    View Code

    展开全文
  • 线程池自我介绍 我是一个线程池(ThreadPoolExecutor),我主要工作管理在我这的多个线程(Thread),让他们能并发地执行个任务同时,又不会造成很大的的系统开销,有人不明白,创建线程有啥开销呢,不是...
  • 线程-线程的创建

    2021-01-24 16:28:20
    **进程:**进程就是一个可执行程序,拥有独立内存空间,一个进程可也有个线程,至少有一个线程。 **线程:**线程进程中一个执行任务(控制单元),个线程可以共享数据。 线程和进程区别: 进程操作...
  • 一、进程与线程的区别 1、进程可以理解成程序的一次执行(即动态的),所以一个程序可以对应一个个进程(程序的次执行),而一个进程往往...因为进程的执行开销比较,把进程划分为多个线程能相对减小执行...
  • 多线程的创建方式

    2019-03-03 15:24:00
    进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销一个进程包含1--n个线程。(进程资源分配的最小单位)  线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和...
  • 进程都拥有自己数据段、代码段和堆栈段,这就造成进程在进行创建、切换、撤销操作时,需要较大的系统开销 为了减少系统开销, 从进程中演化出了线程 线程存在于进程中, 共享进程资源 线程是进程中...
  • 线程创建方式参考:https://www.cnblogs.com/yjd_hycf_space/p/7526608.html进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销一个进程包含1--n个线程。(进程资源分配的最小...
  •  多线程是程序设计中的一个重要方面,尤其在服务器Deamon程序方面。无论何种系统,线程调度的开销都比传统的进程要快得。  Python可以方便地支持多线程。可以快速创建线程、互斥锁、信号量等等元素,支持线程...
  • 实现任务的三种方法:进程,每个进程只有一个线程多线程,一个进程有个线程进程 + 线程进程与线程的优缺点和线程相比,进程的缺点在于:创建进程比创建线程开销大,尤其在Windows系统上;...
  • 进程:每一进程都有自己独立代码和数据空间,进程之间切换开销一个进程包含1~n个线程,进程资源分配最小单位 线程:同一类线程共享代码和数据空间 ,线程之间切换开销较小,线程cpu调度最小单位 ...
  • Java的一大特色多线程

    2019-07-26 18:52:11
    与进程相比较,线程更轻量,创建,销毁一个线程比启动一个新进程开销要小的多,但没有进程就没有线程,进程一终止,其中线程也就没有了。 而线程与进程区别在于每个进程都有自己一整套变量,而线程则共享...
  • 创建,撤消和切换资源都由进程来进行,涉及较大的时空开销以及处理机(SMP)出现。又因为一个进程包含多个线程这些线程可以共享同时享有该进程资源,故引入线程。 线程:称为轻量级进程,程序执行最小单位,...
  • 综述多线程是程序设计中的一个重要方面,尤其在服务器Deamon程序方面。无论何种系统,线程调度的开销都比传统的进程要快得。Python可以方便地支持多线程。可以快速创建线程、互斥锁、信号量等等元素,支持线程...
  • 综述 多线程是程序设计中的一个重要方面,尤其在服务器Deamon程序方面。无论何种系统,线程调度的开销都比传统的进程要快得。Python可以方便地支持多线程。可以快速创建线程、互斥锁、信号量等等元素,支持线程...
  • 1、程序建立1000个线程,有可能造成系统创建大量线程而导致消耗完系统内存,还会增加创建和销毁线程上所花的时间以及系统资源的开销2、在创建线程数的情况下,可以考虑使用线程池以下Java自带的几种线程池:(1)...
  • 1、为什么要使用线程 使用多线程的理由之一和进程相比,它一种非常"节俭"的任务操作方式。我们知道,在Linux系统下,启动一个新的进程必须分配给...据统计,总的说来,一个进程的开销大约是一个线程开销的30倍
  • 一个线程可以创建和撤销另一个线程,执行进程开销大但是安全 线程cpu调度和分配的基本单位 创建线程的方法 继承Thread类 实现Runnable接口 转载于:https://www.cnblogs.com/qf123/p/86712...
  • 创建线程的方式

    2019-08-29 11:46:36
    首先,先来了解一下什么线程?什么进程? 1.进程:操作系统中一个程序的执行周期。...启动、撤销一个进程的开销要比一个线程大。 没有进程就没有线程,进程一旦关闭,所有的线程都会被撤销。 4.创...
  • 多线程的理解

    2021-02-03 17:29:29
    在java中,如果每个请求到达就创建一个新线程,开销是相当的。在实际使用中,创建和销毁线程花费的时间和消耗的系统资源都相当,甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的...
  • 线程同步指的是一个线程在对某个临界资源进行操作时,其他线程都不可以对这个资源进行操作,直到该线程完成操作, 其他线程才能操作,也就是协同步调,让线程按预定先后次序进行运行。线程同步方法有四种:...
  • java多线程)---3种创建方法

    万次阅读 2017-03-28 16:46:50
     进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销一个进程包含1--n个线程。  线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销...
  • 展开全部1、程序建立1000个线程,有可能造成系统创建大量线程而导致消耗完系统内存,还会增加32313133353236313431303231363533e59b9ee7ad9431333363376438创建和销毁线程上所花的时间以及系统资源的开销2、在创建...
  • java线程(创建线程的两种方式)  一、什么线程 线程是一个程序内部的顺序控制流。 线程和进程 1. 进程:每个进程都有独立的代码和数据空间,进程切换开销大。 2. 线程:轻量的进程,同...
  • java多线程1-创建启动

    2017-12-11 10:22:44
    进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1–n个...1、新建状态(New):新创建一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了
  • (1)线程的基本概念:线程是一个程序内部的顺序控制流 (2)线程和进程的区别: · 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销 ·线程可以看成轻量级的进程,同...
  • 多线程

    2020-07-11 17:48:07
    进程和线程的关系就是:一个进程可以包含一个或个线程,但至少会有一个线程。 操作系统调度的最小任务单位其实不是进程,而是线程。 因为同一个应用程序,既可以有个进程,也可以有个线程,因此,实现任务的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,214
精华内容 485
关键字:

创建一个线程的开销是多大