标签: interrupt

我正在Windows机器上的8086程序集中处理一个项目,我需要知道单击了哪个鼠标按钮.这有什么中断？或者我该如何找到这个？

谢谢

有人可以帮我澄清下面的锥形图,以及它们之间的关系吗？

• 可屏蔽中断
• 无法屏蔽中断
• 硬件中断
• 软件中断
• CPU INTR引脚
• EFlags寄存器的IF位

一些具体问题:

• 可屏蔽/不可屏蔽中断与硬件/软件中断之间的关系是什么？
• 可屏蔽性与软件/硬件之间的关系是什么？
• 是否有任何不可屏蔽/软件中断和可屏蔽/硬件中断？
• INTR引脚检测到什么样的中断？
• EFlags寄存器的IF位使能/禁止哪种中断？
• 什么样的中断需要存在中断控制器？

非常感谢.

我开发了一个JSP Web应用程序,在每次请求时都会生成一个新的Java Thread.在每个新生成的线程中,我使用Runtime.exec()创建一个Process,并将进程对象存储在线程中的实例变量中.我有一个要求,我必须杀死创建的子进程,并停止线程.所以,我在线程和overridden方法中覆盖了中断方法,我在实例变量中已经存储过的Process对象上调用了destroy().以下是代码:

public class MyThread extends Thread {
    private Process subprocess;

    @Override
    public void run() {
        subprocess = Runtime.getRuntime().exec("myprocess.exe");
        subprocess.waitFor();
        /*
            Some more statements
        */
    }

    @Override
    public void interrupt() {
        if(subprocess!=null) {
            System.out.println("Destroying Process");
            subprocess.destroy();
        }
        super.interrupt();
    }
}

覆盖中断方法是不合法的吗？重要的是我在中断创建它的线程之前杀死创建的进程.我看到线程确实被中断,因为waitFor()之后的语句没有被执行.但是,destroy()不起作用(但被调用),即使我在完成之前调用interrupt()方法,创建的"myprocess.exe"也会完成执行.有人可以帮我解决这个问题吗？我错过了什么？

提前致谢

我想知道Thread.interrupt()和Thread.currentThread.interrupt()是做同样的事情还是会给出相同的结果？如果没有,有什么区别？

类似的问题是:Thread.sleep()和Thread.currentThread.sleep()之间的区别是什么,因为它们似乎有同样的意义？

我正在开发一个通过网络读取和处理数据的应用程序.在测试程序的连接/断开逻辑时,我注意到我的消费者线程在达到关闭状态时没有关闭.以下是消费者类的剥离版本.

import java.io.InputStream;

public class Consumer implements Runnable
{
   private final InputStream input;
   public Consumer(InputStream input)
   {
      this.input = input;
   }
   @Override
   public void run()
   {      
      byte readBuffer[];
      readBuffer = new byte[1];
      int goodData;

      try
      {
         while(input.available() > 0)
         {
            goodData = input.read(readBuffer);
            while (goodData > 0 )
            {
               System.out.println(readBuffer[0]);
               if ( readBuffer[0] == 27 )
               {
                  System.out.println("Consumer: found closing byte and closing thread "+Thread.currentThread().getName());
                  //this is the last packet, so interupt thread to close
              Thread.currentThread().interrupt();
              //return;
              //Thread.currentThread().stop(new InterruptedException("Attempting to …

如您所见,这是APUE中的示例.

#include "apue.h"

static void sig_int(int sig);

int main(int argc, char **argv)
{
    char buf[MAXLINE];
    pid_t pid;
    int status;

    if (signal(SIGINT, sig_int) == SIG_ERR) //sig_int is a simple handler function
        err_sys("signal error");

    printf("%% ");
    while (fgets(buf, MAXLINE, stdin) != NULL) {
    //This is a loop to implement a simple shell
    }
    return 0;
}

这是信号处理程序

void sig_int(int sig)   
/*When I enter Ctrl+C, It'll say a got SIGSTOP, but it would terminate.*/
{
    if (sig == SIGINT)
        printf("got SIGSTOP\n");
}

当我输入Ctrl …

我正在尝试在Solaris上运行的C语言中实现TCP服务器和客户端。我是套接字的新手，并以Beej指南为例。

对于初学者来说，我希望客户端以的形式向服务器发送消息word1 word2。收到后，我希望服务器word2从消息中提取并将其发送回客户端。

初始客户端->服务器消息发送工作正常。但是服务器->客户端响应不起作用。有几种故障症状：

1. 服务器似乎甚至没有尝试对send()客户端执行任何操作。
2. 接收到客户端的消息后，服务器将打印：accept: Interrupted system call，然后返回到while(1)循环的顶部并保持在那里，直到我按Ctrl-C为止。
3. 客户端的调用recv()返回0个字节。

我在这里找到一个旧线程，最后一个帖子说：

子进程终止时，accept被子进程中断，它将信号发送回父进程（SIGCHLD，如果我还记得写的话）。您可以忽略SIGCHLD，也可以编写accept（）以便更好地处理中断（errno设置为EINTR）

但是，我不明白这一点。为什么子进程在尝试该send()部分之前就终止了？“更好地处理中断”是什么意思？

搜索更多内容后，我在堆栈溢出上发现了这个问题：如何处理EINTR（中断的系统调用）。

我尝试将代码添加到接受的答案中，替换write()为send()，但是我仍然看到相同的行为。

服务器代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/wait.h>
#include <signal.h>

const char* nodename = "localhost";
const char* FILESERV1_LISTEN_PORT = "41063";
const unsigned int MAXDATASIZE = 100; …

对于PA1和PC1的例子,是否可以从相同的EXTI线获得多个中断,它们都在EXTI1上.

因此,通过点击PA1上的按钮,LED在PB6上亮起,然后点击PC1,LED在PC0上切换.

微控制器==> STM32F091

这是我用于2个不同行的中断的代码:

//PC1
SYSCFG->EXTICR[0] |= SYSCFG_EXTICR1_EXTI1_PA;
EXTI->IMR = EXTI_IMR_MR1;
EXTI->RTSR = EXTI_RTSR_TR1;
EXTI->FTSR = EXTI_FTSR_TR1; 
//PB0
SYSCFG->EXTICR[0] |= SYSCFG_EXTICR1_EXTI1_PC;
EXTI->IMR |= EXTI_IMR_MR1; 
EXTI->RTSR |= EXTI_RTSR_TR1; 
EXTI->FTSR |= EXTI_FTSR_TR1;
NVIC_EnableIRQ(EXTI0_1_IRQn);
NVIC_SetPriority(EXTI0_1_IRQn,0);

中断处理程序:

void EXTI0_1_IRQHandler(void)
{
if ((EXTI->PR & EXTI_PR_PR1) == EXTI_PR_PR1)  /* Check line 1 has triggered      the IT */
{
EXTI->PR = EXTI_PR_PR1; /* Clear the pending bit */
GPIOC->ODR ^= 1<<0;
}
if ((EXTI->PR & EXTI_PR_PR0) == EXTI_PR_PR0)  /* Check line 0 has triggered  the IT …

根据ACPI规范，FADT（固定的ACPI描述表）表包含一个向OS 报告SCI中断号的字段。该字段定义如下：

我将FADT表转储到了Intel x86平台上，并看到SCI中断与该数字相关联9：

但是根据《英特尔手册》，0-31保留了IA体系结构定义的中断的向量。具体来说，9定义为：

因此，根据说明，9I386处理器之后不会生成。因此，我想这就是SCI 可以挽救 9的原因。这可以看作是ACPI规范的x86特定实现。

我说得对吗？

加1

似乎我在这里误解了一些东西。稍后将更新。

我正在使用Spring（v4）ThreadPoolTaskExecutor执行一些连续的可运行任务。当应用程序关闭时，我希望正常关闭执行器，以便任务有一些时间在继续关闭之前完成其迭代。如果活动任务在执行者等待时间到期之前（例如ThreadPoolTaskExecutor.setAwaitTerminationSeconds()）完成了其迭代，则我不希望它开始另一个迭代。到目前为止，我还无法完成此任务。我有以下执行程序配置：

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setWaitForTasksToCompleteOnShutdown(true);     
executor.setAwaitTerminationSeconds(30);

我的任务基本上是这样设置的：

    myExecutor.execute(() -> {
        while(true) {
            doSomething();
        }
    });

我假设我需要在执行程序关闭时在线程中设置一个标志，以使循环中断。还有其他推荐的方法吗？