精华内容
下载资源
问答
  • 锁竞争、上下文切换、线程迁移的监控 程序的多线程应用,必然会出现锁的竞争。锁竞争一次消耗的高达80,000个(甚至更高)时钟周期,那么锁的竞争过多必然会导致性能瓶颈 既然如此消耗性能,又该如何去监测锁竞争呢? 第...

    锁竞争、上下文切换、线程迁移的监控
    程序的多线程应用,必然会出现锁的竞争。锁竞争一次消耗的高达80,000个(甚至更高)时钟周期,那么锁的竞争过多必然会导致性能瓶颈

    既然如此消耗性能,又该如何去监测锁竞争呢?

    第一步:竞争的监测

    第二步:若出现锁的竞争,就需要利用线程转储(thread dump)去分析锁竞争严重的原因了

    解释如下:

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 如题,即使不使用,它们也会从WAITTING 到 RUNNABLE 吗,望解答 ; position:absolute; top:-9.58403px">   </div>
  • This pattern comes up a lot but I can't find a straight answer.An non-critical, un-friendly program might dowhile(True):# do some workUsing other technologies and platforms, if you want to allow this ...

    This pattern comes up a lot but I can't find a straight answer.

    An non-critical, un-friendly program might do

    while(True):

    # do some work

    Using other technologies and platforms, if you want to allow this program to run hot (use as much CPU cycles as possible) but be polite - allow other programs who are running hot to effectively slow me down, you'd frequently write:

    while(True):

    #do some work

    time.sleep(0)

    I've read conflicting information about whether the latter approach would do what I'd hope on python, running on a linux box. Does it cause a context switch, resulting in the behavior I mentioned above?

    EDIT: For what's worth, we tried a little experiment in Apple OSX (didn't have a linux box handy). This box has 4 cores plus hyperthreading so we spun up 8 programs with just a

    while(True):

    i += 1

    As expected, the Activity Monitor shows each of the 8 processes as consuming over 95% CPU (apparently with 4 cores and hyperthreading you get 800% total). We then spun up a ninth such program. Now all 9 run around 85%. Now kill the ninth guy and spin up a program with

    while(True):

    i += 1

    time.sleep(0)

    I was hoping that this process would use close to 0% and the other 8 would run 95%. But instead, all nine run around 85%. So on Apple OSX, sleep(0) appears to have no effect.

    解决方案

    I'd never thought about this, so I wrote this script:

    import time

    while True:

    print "loop"

    time.sleep(0.5)

    Just as a test. Running this with strace -o isacontextswitch.strace -s512 python test.py gives you this output on the loop:

    write(1, "loop\n", 5) = 5

    select(0, NULL, NULL, NULL, {0, 500000}) = 0 (Timeout)

    write(1, "loop\n", 5) = 5

    select(0, NULL, NULL, NULL, {0, 500000}) = 0 (Timeout)

    write(1, "loop\n", 5) = 5

    select(0, NULL, NULL, NULL, {0, 500000}) = 0 (Timeout)

    write(1, "loop\n", 5) = 5

    select(0, NULL, NULL, NULL, {0, 500000}) = 0 (Timeout)

    write(1, "loop\n", 5)

    select() is a system call, so yes, you are context switching (ok technically a context switch is not actually necessary when you change to kernel space, but if you have other processes running, what you're saying here is that unless you have data ready to read on your file descriptor, other processes can run until then) into the kernel in order to perform this. Interestingly, the delay is in selecting on stdin. This allows python to interrupt your input on events such as ctrl+c input, should they wish, without having to wait for the code to time out - which I think is quite neat.

    I should note that the same applies to time.sleep(0) except that the time parameter passed in is {0,0}. And that spin locking is not really ideal for anything but very short delays - multiprocessing and threads provide the ability to wait on event objects.

    Edit: So I had a look to see exactly what linux does. The implementation in do_select (fs\select.c) makes this check:

    if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {

    wait = NULL;

    timed_out = 1;

    }

    if (end_time && !timed_out)

    slack = select_estimate_accuracy(end_time);

    In other words, if an end time is provided and both parameters are zero (!0 = 1 and evaluates to true in C) then the wait is set to NULL and the select is considered timed out. However, that doesn't mean the function returns back to you; it loops over all the file descriptors you have and calls cond_resched, thereby potentially allowing another process to run. In other words, what happens is entirely up to the scheduler; if your process has been hogging CPU time compared to other processes, chances are a context switch will take place. If not, the task you are in (the kernel do_select function) might just carry on until it completes.

    I would re-iterate, however, that the best way to be nicer to other processes generally involves using other mechanisms than a spin lock.

    展开全文
  • 减少上下文切换

    2019-02-10 17:22:37
    上下文切换又分为2种:让步式上下文切换和抢占式上下文切换。前者是指执行线程主动释放CPU,与锁竞争严重程度成正比,可通过减少锁竞争和使用CAS算法来避免...因为多线程竞争锁时会引起上下文切换。 使用CAS算法。这...

    上下文切换又分为2种:让步式上下文切换和抢占式上下文切换。前者是指执行线程主动释放CPU,与锁竞争严重程度成正比,可通过减少锁竞争和使用CAS算法来避免;后者是指线程因分配的时间片用尽而被迫放弃CPU或者被其他优先级更高的线程所抢占,一般由于线程数大于CPU可用核心数引起,可通过适当减少线程数和使用协程来避免。

    总结一下:

    减少锁的使用。因为多线程竞争锁时会引起上下文切换。
    使用CAS算法。这种算法也是为了减少锁的使用。CAS算法是一种无锁算法。
    减少线程的使用。人物很少的时候创建大量线程会导致大量线程都处于等待状态。
    使用协程。
    转载https://blog.csdn.net/qq_34337272/article/details/79844051

    展开全文
  • 上下文切换CPU通过时间片分配算法来循环执行任务,当前任务执行一个时间片后会切换到下一个任务...减少上下文切换的方法有:无锁并发编程:多线程竞争锁时,会引起上下文切换,可以用一 些办法来避免使用锁,如将数...

    上下文切换

    CPU通过时间片分配算法来循环执行任务,当前任务执行一个时间片后会切换到下一个任务。但是在切换前会保存上一个任务的状态,以便下次切换回这个任务时,可以再加载这个任务的状态。所以任务从保存到再加载的过程就是一次上下文切换。

    并发执行不一定比串行执行快,因为线程有创建和上下文切换的开销。

    减少上下文切换的方法有:

    无锁并发编程:多线程竞争锁时,会引起上下文切换,可以用一 些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据

    CAS算法(compare-and-swap):Java的Atomic包使用CAS算法来更新数据,而不需要加锁

    public class AtomicCounter{

    private final AtomicInteger counter = new AtomicInteger(0);

    public int getValue(){

    return counter.get();

    }

    public void increment(){

    while(true) {

    int existingValue = getValue();

    int newValue = existingValue + 1;

    if(counter.compareAndSet(existingValue, newValue)) {

    return;

    }

    }

    }

    }

    复制代码

    使用最少线程:避免创建不需要的线程,比如任务很少,但是创建了很多线程来处理,这样会造成大量线程都处于等待状态

    协程(Quasar):在单线程里实现多任务的调度,并在单线程里维持多个任务间的切换

    死锁

    锁是个非常有用的工具,运用场景非常多,因为它使用起来非常简单,而且易于理解。但同时它也会带来一些困扰,那就是可能会引起死锁,一旦产生死锁,就会造成系统功能不可用。

    避免死锁的几种常见方法:

    避免一个线程同时获取多个锁

    避免一个线程在锁内同时占用多个资源,尽量保证每个锁只占用一个资源

    尝试使用定时锁,使用lock.tryLock(timeout)来替代使用内部锁机制

    对于数据库锁,加锁和解锁必须在一个数据库连接里,否则会出现解锁失败的情况

    资源限制

    资源限制是指在进行并发编程时,程序的执行速度受限于计算机硬件资源或软件资源。 例如服务器的带宽只有2Mb/s,某个资源的下载速度是1Mb/s每秒,系统启动10个线程下载资源,下载速度不会变成10Mb/s,所以在进行并发编程时,要考虑这些资源的限制。

    常见资源限制有:

    带宽的上传/下载速度

    硬盘读写速度

    CPU的处理速度

    数据库的连接数

    socket连接数等

    在并发编程中,将代码执行速度加快的原则是将代码中串行执行的部分变成并发执行,但是如果将某段串行的代码并发执行,因为受限于资源仍然在串行执行,这时候程序不仅不会加快执行反而会更慢,因为增加了上下文切换和资源调度的时间。

    展开全文
  • 引起上下文切换的原因引起上下文切换的原因如下 引起上下文切换的原因如下 当前正在执行的任务完成,系统的cpu正常调度下一个任务 当前正在执行的任务遇到i/o等阻塞操作,调度器挂起此任务,继续调度下一个任务。 ...
  • 后来**@冬神**点醒了我,就是这个可视化的表格中没有上下文。 现将**[日期]**这一列放入表格中: 会发现这次显示的没有问题,什么原因呢? 结合之前**@嘿神**说的,迭代器激活行上下文进行取值。 在上面的代码中,...
  • 多线程编程如何减少上下文切换 上下文切换: CPU通过时间片分配算法来循环执行任务,...多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同
  • 多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一 些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。 CAS算法。Java的Atomic包使用CAS算法来更新数据,而不...
  • 多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。 ·CAS算法。Java的Atomic包使用CAS算法来更新数据,而不...
  • 无锁并发编程多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以采取一些方法避免采取锁,如数据的ID按照HASH算法取模,不同的线程处理不同段的数据二.使用最少线程数量三.CAS算法四.使用协程...
  • 简介:介绍什么是上下文切换以及上下文切换所带来的挑战 ...多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程
  • 切换上下文,阻塞,内存同步

    千次阅读 2013-12-06 16:36:14
    如果主线程是唯一可调度的线程,它决不会被排除在调度之外。从另一方面看,如果可运行的线程数大于CPU...这会引起上下文切换,它会保存当前运行线程的执行上下文,并重建新调入线程的执行上下文。 切换上下文是
  • 多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。2. CAS算法。Java的Atomic包使用CAS算法来更新数据,而不...
  • 多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以尽量减少锁的竞争或避免使用锁,比如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。 CAS算法。Java的(Atomic)原子包使用CAS算法来...
  • 七氟醚麻醉不会引起老年大鼠的上下文恐惧记忆障碍或mPFC LFP网络的局部人群连通性改变。
  • 测试nginx有效请求,通过直接连接jetty和nginx两种方式的对比,发现连接nginx的方式比连jetty,同样的cpu 利用率,load相差2左右。上下文的切换频率几乎差一倍,引起TPS的波动。
  • 先来看一个测试表格 发现多线程不一定更快,...多线程竞争锁时,会引起上下文切换,所以多线程处理数据时,可以用一 些办法来避免使用锁,如将数据的ID按照Hash算法取模分段,不同的线程处理不同段的数据。 2.CA...
  • spring上下文配置 时不时地,关于Spring框架如何充满XML,它多么可怕和冗长,以及作者因此将永远不会使用它,引起了愤怒的帖子或评论。 当然,那完全是胡扯。 首先,创建Spring时,XML非常热门。 J2EE部署描述符(是...
  • 原子上下文

    千次阅读 2015-07-22 10:55:59
    一般来讲原子上下文指的是在中断或软中断中,以及在持有自旋锁的时候。内核提供了四个宏来判断是否处于这几种情况里: #define in_irq() (hardirq_count()) //在处理硬中断中 #define in_so
  • 中断处理程序处于中断上下文,而中断上下文是不参与调度的,这样中断上下文不能出现可能休眠的操作,因为中断上下文一旦休眠就会交出cpu,而中断上下文不参与调度,也就是交出cpu时不会保存上下文,这样一旦交出cpu...
  • 先前的研究集中于空间方面的共现或上下文,其中很少考虑时间方面的上下文。 在本文中,考虑到共现,上下文和移动性周期性,我们针对此问题提出了一种新颖的社会关系预测方法,称为多视图上下文共现(MVCC)。 ...
  • 我们大家可能都熟悉CSS中的z-index属性,需要跟大家讲的是,z-index实际上只是CSS层叠上下文和层叠顺序中的一叶小舟。 一、什么是层叠上下文 层叠上下文,英文称作“stacking context”。是HTML中的一个
  • css-块级格式上下文

    2018-11-13 21:56:00
     块级格式上下文(Block Formatting Context)是CSS中一个相对冷门的概念,今天被问到才引起注意,下文简单介绍下它的用法,学习资料多来源于网络,实际开发中遇到再继续更博吧。  BFC(Block formatting ...
  • 使用fragment后如果横屏运行后会crashes 这个错误也很明显 就是 没有空的构造函数 所以我加上了 空的构造函数后 又有新问题了 使用上下文对象 Context的时候有问题了 用有参的构造函数传过来 总是为空  果断去看...
  • 文章目录线程上下文切换进程上下文寄存器程序计数器PCB:切换桢上下文切换引起线程上下文切换的原因 线程上下文切换 巧妙地利用了时间片轮转的方式, CPU 给每个任务都服务一定的时间,然后把当前任务的状态保存下来...

空空如也

空空如也

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

引起上下文