标签: interrupt

我试图在Python中运行一个简单的多进程应用程序.主线程产生1到N个进程并等待它们都完成处理.每个进程都运行一个无限循环,因此它们可以在没有用户中断的情况下永远运行,因此我输入了一些代码来处理KeyboardInterrupt:

#!/usr/bin/env python
import sys
import time
from multiprocessing import Process

def main():
    # Set up inputs..

    # Spawn processes
    Proc( 1).start()
    Proc( 2).start()

class Proc ( Process ):
    def __init__ ( self, procNum):
        self.id = procNum
        Process.__init__(self)

    def run ( self ):
        doneWork = False

        while True:

            try:
                # Do work...
                time.sleep(1)
                sys.stdout.write('.')

                if doneWork:
                    print "PROC#" + str(self.id) + " Done."
                    break

            except KeyboardInterrupt:
                print "User aborted."
                sys.exit()

# Main Entry
if __name__=="__main__":
    main()

问题是当使用CTRL-C退出时,即使进程似乎立即退出,我也会收到一个额外的错误:

......User aborted.
Error …

无论如何,Ctrl+c当脚本运行时,我可以让我的脚本执行我的一个函数吗？

我首先了解了计算机如何在原始单个存储程序机器方面工作.

现在我正在学习多任务操作系统,日程安排,上下文切换等等.我认为除了一件事之外,我对这一切都有相当好的把握.我一直认为CPU是一种不间断充电的东西.它总是知道接下来要去哪里(程序计数器),并且无限制地进入该指令等.

显然情况并非如此,因为我的台式计算机CPU并非始终以100%运行.那么CPU如何自行关闭或自行关闭,以及操作系统在这方面扮演什么角色？我猜测CPU上有一个输入允许它掉电......如果没有什么可以安排,操作系统可以设置它,但下一个逻辑问题是它如何重新启动？我猜两件事中的任何一件:

• 它永远不会完全关闭,只是以非常低的频率运行,等待调度程序再次忙碌
• 它完全关闭但被中断唤醒

我搜索了所有关于这方面的信息并且相当空手而归.任何见解都会非常感激.

我有一个问题我不知道它是否完全有意义:如果在中断向量中有一个中断函数,其中每个地址槽是指向某个处理中断的函数的指针(服务的类型,并在内核模式下运行) ),那么我的问题是:

制作软件中断而不是使用系统调用(又称函数)会有所作为吗？让我们举一个例子:我可以在Windows中以两种方式销毁一个进程:

1. 我只是叫"ExitProcess"
2. 我只是在汇编中使用中断"int80h"(好吧,至少在Linux中.在Windows中是否可以？)

两者都可以工作并给出相同的结果.我认为唯一不同的是中断会停止CPU,而系统调用,因为它不是一个中断,它不会停止CPU做其他事情(这允许多线程而不是为了不需要停止的东西而停止)整个CPU).

我真的想要的是,WIN32API(或任何其他操作系统)中的所有功能都可以实现为中断而不会产生任何影响.然后,这将使WIN32API成为一个不需要的层.你不觉得吗？那么,软件中断和系统调用之间有什么区别？您只需要调用WIN32API中的函数来请求服务,并且使用中断,您只需要传递参数(通过堆栈或寄存器)并调用由数字标识的指定中断.我能想到的唯一原因是每个进程都创建了DLL(这些实例),并且只使用了你需要的函数.

这对于中断是不可能的,并且所有进程将共享相同的数据,这并不总是人们想要的.

PD:这是一个额外的问题,这个问题超出了主题但是有点问题:我在哪里可以看到我可以在操作系统中调用的所有中断的参考/列表？我无处可见任何文档.

我想杀死陷入死锁状态的线程.首先,我们可以使用类中的方法检测处于死锁状态的线程ID.findDeadlockedThreads()ThreadMXBeanjava.lang.management

于是,我想通过杀死线程ID线程,因此我有两个相关的问题:
(1)如何获得通过线程ID线程的控制？
(2)如何杀死被阻塞的线程？我认为调用interrupt()方法会给线程一个异常并将杀死线程.

我正在使用一个多线程环境,一个Thread通过反复调用不断地监听用户输入scanner.nextLine().要结束应用程序,此runloop会被另一个线程停止,但监听线程将不会停止,直到最后一个用户输入(由于阻塞性质nextLine()).

关闭流似乎不是一个选项,因为我正在读取System.in,它返回一个InputStream不可关闭的.

有没有办法打断扫描仪的阻塞,以便它会返回？

谢谢

是否存在中断服务程序来帮助我清除终端屏幕？它会在Windows上运行吗？

这是参考Path#register方法.如果一个线程正在运行一个包含该方法的块,另一个线程会事先中断它.然后发现该方法清除了中断状态.

在文档中没有提到它清除了线程的中断状态.

要复制

import java.io.*;
import java.nio.file.*;
import static java.nio.file.LinkOption.*;
import static java.nio.file.StandardWatchEventKinds.*;
import java.nio.file.attribute.*;


public class WatchDir {

private final WatchService watcher;


private void register(Path dir) throws IOException {
    //interrupt itself
    Thread.currentThread().interrupt();
    boolean before = Thread.currentThread().isInterrupted();
    WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
    boolean after = Thread.currentThread().isInterrupted();

    if(before){
        if(!after){
            System.out.println("--------------------BUG-------------------");
            System.out.format("Interrupt Status: true before making call to Path#register for folder folder: %s\n", dir);
            System.out.format("Interrupt Status: false after making call to Path#register for folder folder: %s\n", dir);
            System.out.println("The …

我有一个函数a执行一些任务，另一个函数b是对某些事件的回调。每当发生事件时，b都会调用function并且我想让它能够中断 function 的执行a。这两个函数都在同一个类中声明。

Functiona不应该调用 function b。功能b是完全独立的，它是对来自ROS：机器人操作系统的“用户面部检测”等外部事件的回调。

我需要的基本上是像 Ctrl+C 这样的东西，它可以从 Python 中调用，它只会中止目标函数而不是整个程序。

这可以在 Python 中完成吗？

众所周知,有两种方法可以避免高负载网络中的硬件中断的一些开销,当硬件中断太多时,切换到它们需要花费太多时间.对于程序风格的性能和选择方法非常重要.

1. NAPI(新API) - 不使用硬件中断,并且每隔一段时间轮询以太网设备.Linux内核默认使用中断驱动模式,只有当传入数据包流量超过某个阈值时才切换到轮询模式.

http://en.wikipedia.org/wiki/New_API 内核可以定期检查传入网络数据包的到达而不会中断,从而消除了中断处理的开销.

2. 中断合并 - 使用硬件中断,但如果发生中断,则禁用中断并开始轮询,持续一段时间,然后轮询终止并激活中断.

https://en.wikipedia.org/wiki/Interrupt_coalescing一种技术,在这种技术中,通常会触发硬件中断的事件会被阻止,直到一定量的工作挂起或超时计时器触发为止.

两种方法都没有显着的中断成本 - 这是默认中断驱动模式的优势.

但第二种方法 - 中断合并更合理,因为它:

• 减少延迟 - 一旦程序包到达,立即尝试立即处理它,如果最近发生了中断,则立即轮询它.NAPI对面不会立即处理帧,但会等待一段时间进行下一次轮询.

• 较少的CPU使用率 - 仅在至少有一个数据包到来时才开始轮询.但即使没有收到框架,也不是徒劳无功,就好像是NAPI一样.

IRQ Coalesce之前NAPI有哪些优势？