Java 在单例bean中调用WatchService时出现问题

我们希望定期观察文件的变化，我们正在使用JBoss7。下面是我的代码片段。我在singletonbean的postconstruct方法中初始化了watcher，并安排了一个轮询watch事件的方法。当我第一次修改文件时，我可以观察到这些更改，但是没有收到对文件的后续修改。有人能告诉我可能是什么问题吗

  @Startup
  @ConcurrencyManagement(ConcurrencyManagementType.BEAN)
  @Interceptors(NonThrowingPostConstructInterceptor.class)
  @Singleton
  @Service
  @LocalBinding(jndiBinding=IHeartBeatProducerService.JNDI_LOCAL_BINDING)
 public class HeartBeatProducerService extends EMSingletonService implements IHeartBeatProducerService{

@EJB(mappedName=IMessageService.JNDI_LOCAL_BINDING)
public IMessageService messageService;

@EJB(mappedName=ICommandExecutionService.JNDI_LOCAL_BINDING)
public ICommandExecutionService commandService;

private final static String LAST_OPERATION_COMPLETED="Last Operation Completed";

private final static String STATUS="Status"; 

private WatchService watcher;

private Path dir;

private String concServer; 

public static final String TOPIC="foo";

private IMLogger logger = new IMLogger("foo");

private String content=null; 

@PostConstruct
@Override
public void init() {
    // TODO Auto-generated method stub
    super.init();
    try {


        watcher = FileSystems.getDefault().newWatchService();
        dir=Paths.get("/shared/foo");
        dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY);
        logger.entering(0, IHeartBeatProducerService.class.getSimpleName(), "Initializing Heart Beat", new String[]{"Entered"});

    } catch (IOException e) {

        e.printStackTrace();
    }
}

@Schedule(second="*/10", minute = "*", hour="*")
private void checkStatus()
{
    logger.entering(0, IHeartBeatProducerService.class.getSimpleName(), "Checking Status", new String[]{"Entered"});
    final String[] command={"pidof","server"};
    commandService.run(command, null, false);
    concServer=(commandService.getExitCode()==0)?"UP":"DOWN";
    if(concServer.equals("UP"))
    {
        watch();
    }
    else
    {
        content="foo:Failed";
    }
    produce();
}


public void watch()
{       
        logger.entering(0, IHeartBeatProducerService.class.getSimpleName(), "Entering watch()", new String[]{"Entered"});
        WatchKey key = null;

        try 
        {           
         key = watcher.take();
        }
        catch (InterruptedException e)
        {               
            logger.error(HeartBeatProducerService.class.getSimpleName(),"Interupted Exception " +  e.getMessage());
        }

        for ( WatchEvent<?> event: key.pollEvents())
        {
            WatchEvent.Kind kind = event.kind();

            logger.info(HeartBeatProducerService.class.getSimpleName(),"Watch Event :" + kind.name()); 

            if(kind.name().equals("OVERFLOW"))
            {
                continue;
            }
            if(kind.name().equals("ENTRY_MODIFY"))
            {
                Path concLog = (Path) event.context();

                logger.info(HeartBeatProducerService.class.getSimpleName(),"Modified File Name:" + concLog.getFileName()); 

                if(concLog.endsWith("current_status.txt"))
                {
                    logger.info(HeartBeatProducerService.class.getSimpleName(), "Reading Status");                  
                    readStatus();
                }
            }

        }

        boolean valid = key.reset();

        if ( !valid)
        {               
            logger.error(HeartBeatProducerService.class.getSimpleName(),"Key Unregistered"); 
        }
}





private void parse(String output)
{       
    // parse file contents
}

private void readStatus() {

    //read status and parse()

}
private void produce() 
{

    try {

        messageService.publish(TOPIC, content, PublishType.ASync);

    } catch (MessageException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

@启动
@ConcurrencyManagement（ConcurrencyManagementType.BEAN）
@拦截器（非throwingPostConstructionReceptor.class）
@独生子女
@服务
@LocalBinding（jndiBinding=IHeartBeatProducerService.JNDI_LOCAL_BINDING）
公共类HeartBeatProducerService扩展EMSingletonService实现IHeartBeatProducerService{
@EJB（mappedName=IMessageService.JNDI_LOCAL_绑定）
公共IMessageService消息服务；
@EJB（mappedName=ICommandExecutionService.JNDI\u LOCAL\u绑定）
公共ICommandExecutionService命令服务；
私有最终静态字符串LAST\u OPERATION\u COMPLETED=“LAST OPERATION COMPLETED”；
私有最终静态字符串STATUS=“STATUS”；
私人观察者；
专用路径目录；
私有字符串服务器；
公共静态最终字符串TOPIC=“foo”；
专用IMLogger=新IMLogger（“foo”）；
私有字符串内容=null；
@施工后
@凌驾
公共void init（）{
//TODO自动生成的方法存根
super.init（）；
试一试{
watcher=FileSystems.getDefault（）.newWatchService（）；
dir=path.get（“/shared/foo”）；
目录寄存器（watcher、StandardWatchEventTypes.ENTRY\u MODIFY）；
正在输入（0，IHeartBeatProducerService.class.getSimpleName（），“初始化心跳”，新字符串[]{“已输入”}）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
@时间表（秒=“*/10”、分钟=“*”、小时=“*”）
私有无效检查状态（）
{
正在输入（0，IHeartBeatProducerService.class.getSimpleName（），“正在检查状态”，新字符串[]{“已输入”}）；
最后一个字符串[]命令={“pidof”，“server”}；
commandService.run（command，null，false）；
concServer=（commandService.getExitCode（）==0）？“向上”：“向下”；
if（concServer.equals（“UP”））
{
手表（）；
}
其他的
{
content=“foo:失败”；
}
产生（）；
}
公共空间观察（）
{       
正在输入（0，IHeartBeatProducerService.class.getSimpleName（），“正在输入watch（）”，新字符串[]{“已输入”}）；
WatchKey=null；
尝试
{           
key=watcher.take（）；
}
捕捉（中断异常e）
{               
错误（HeartBeatProducerService.class.getSimpleName（），“中断异常”+e.getMessage（））；
}
for（WatchEvent事件：key.pollEvents（））
{
WatchEvent.Kind-Kind=event.Kind（）；
logger.info（HeartBeatProducerService.class.getSimpleName（），“监视事件：”+kind.name（））；
if（kind.name（）.equals（“溢出”））
{
继续；
}
if（kind.name（）.equals（“ENTRY_MODIFY”））
{
Path concLog=（Path）event.context（）；
logger.info（HeartBeatProducerService.class.getSimpleName（），“修改后的文件名：”+concLog.getFileName（））；
if（concLog.endsWith（“current_status.txt”））
{
info（HeartBeatProducerService.class.getSimpleName（），“读取状态”）；
readStatus（）；
}
}
}
布尔有效值=key.reset（）；
如果（！有效）
{               
错误（HeartBeatProducerService.class.getSimpleName（），“密钥未注册”）；
}
}
私有void解析（字符串输出）
{       
//解析文件内容
}
私有void readStatus（）{
//读取状态和解析（）
}
私人产品
{
试一试{
publish（主题、内容、PublishType.ASync）；
}捕获（消息异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}

}

---

已经有一个链接解释了@Asynchronous标记（）的相同之处。但是，我需要知道这种方法可能有什么错误。

您的watch方法需要在无限循环中运行。现在发生的事情是在

     try {           
       key = watcher.take();
     }

处理事件，然后watch（）方法完成。试一试

     for(;;) {

---

在上述行之前，在有效性检查之后结束for块。您是否看到了？

上的示例，但我已将手表（）的时间安排为每10秒一次。。查看checkStatus方法。Saravana，我没有看到你的注释。我不确定是什么问题。我想知道当您对一个已被take（）调用阻止的WatchService调用take（）时会发生什么？不幸的是，我没有一个JBoss安装来尝试重现您的问题。也许在不使用@Schedule注释的情况下尝试它是个好主意，看看它是否能按预期工作（在循环中）？-约翰