[顶者有分]JBOSS(3.2.6)运行10小时左右会死掉，重启后恢复正常，这个问题大家碰到过吗？怎么解决？急啊！！！

Question

帮楼主顶下，我以前也碰到过这个问题。当时我用的是JBOSS4.0.2，启动服务后过10个小时左右就停了，一直没找到原因，于是改用tomcat，郁闷。

Answer 1

呵呵,实在不行你写一个程序在深夜定时重启动jboss,或者启动垃圾回收.

Answer 2

我碰到过这样的问题，我们做的东西也是需要24小时运行，很长时间不出问题，但是出了问题就是很频繁的，我们用的是3.2.4
由于这个jboss技术上不像付费产品，没有技术支持，所以不排除有这样的长时间问题，但是我们处理问题的态度，还是先要从我们自己方面找问题，比如你的软件是不是设计到jboss里的程序调用硬件方面的东西，比如我们做的东西，就涉及到调用底层硬件播放卡的问题。主要还是程序的内存使用吧。我曾经用jprofiler详细分析了内存的使用问题，总是偶尔存在一个峰值，超过jboss的最大内存使用量，很让人郁闷，没有办法哟，只能详细的从代码着手处理。
   针对7*24小时的产品，我个人觉得还是weblogic,websphere等产品，jboss免费当然好，但是出了问题也是受不了的
   我们改变不了老板决定用jboss，那就从备份上做好准备，双机的热备份吧

Answer 3

如果是重起以后可以恢复正常.你可以检查一下里面的日志或者是log的文件.看看是那里超负何了.

Answer 4

一般都是自己的程序问题。
你可以 开个空的 JBOSS 运行几天，写个程序模拟用户看看JBOSS会不会死就知道了。

Answer 5

楼上几位兄弟说的都做过，比如，程序运行后，长期不操作（操作会带来很多我程序中对内存的使用），jboss运行是没有问题的，但是经常操作，jboss就不行了，代码量很大，基本是存在对内存的使用问题，目前主要碰到java的垃圾回收机制，我们并不能确定内存是否释放。
在java虚拟机中，如果一个对象被长期引用，则进入隐形状态，此时这个对象可能不会再被引用，但仍然是可以到达的，隐形状态是内存泄露的重要原因。尤其当一个隐形状态的对象又引用了其他对象时，这些对象占有的内存都是无法回收的，直到对处于隐形状态的对象应用结束，垃圾收集器才能最终回收这部分空间。
    我碰到问题的程序的，就包括了大量长期被引用的对象！郁闷哟而且内存的使用量，由于功能的需要，本来就非常高！
    现在这在想办法，去处理。换个角度去处理问题，我们只能学会去适应JVM

Answer 6

你需要分析你的现状和程序的关系一般来说可能是JVM过低引起如果你的访问量增加了，也需要更改默认的几个配置，比如连接线程数，线程池数，排队数都需要设置的

Answer 7

多谢大家的回复，由于没有找到问题发生的确切原因，所以采取了如下的策略： 通过ping 8080端口，监听jboss是否启动正常，如果ping不通，
 那么就先执行shutdown，关闭jboss，再执行run来开启jboss代码写在一个文件中，命名为ListenPortAndRestartService.java，用到的资源文件为restartJBossService.properties，内容如下：
needListen=true

Answer 8

下面是ListenPortAndRestartService.java的内容：
=============================================================
/*
 * @(#)Ping.java 1.2 01/12/13
 * Connect to each of a list of hosts and measure the time required to complete
 * the connection.  This example uses a selector and two additional threads in
 * order to demonstrate non-blocking connects and the multithreaded use of a
 * selector.
 *
 * Copyright 2001-2002 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * -Redistributions of source code must retain the above copyright
 * notice, this  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduct the above copyright
 * notice, this list of conditions and the following disclaimer in
 * the documentation and/or other materials provided with the
 * distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY
 * DAMAGES OR LIABILITIES  SUFFERED BY LICENSEE AS A RESULT OF  OR
 * RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR
 * ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE
 * FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT,
 * SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF
 * THE USE OF OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that Software is not designed, licensed or
 * intended for use in the design, construction, operation or
 * maintenance of any nuclear facility.
 */
======================================================
文件太长，请合并下面的部分

Answer 9

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.LinkedList;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.Date;
import java.io.File;
import java.text.SimpleDateFormat;
import java.io.FileOutputStream;
import java.io.RandomAccessFile;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.FileNotFoundException;class Ping {  // The default daytime port
  static int DAYTIME_PORT = 8080;  // The port we'll actually use
  static int port = DAYTIME_PORT;  // Representation of a ping target
  //
  static class Target {    InetSocketAddress address;
    SocketChannel channel;
    Exception failure;
    long connectStart;
    long connectFinish = 0;
    boolean shown = false;
    static boolean show = false;
    Target(String host) {
      try {
        address = new InetSocketAddress(InetAddress.getByName(host),
                                        port);
      }
      catch (IOException x) {
        failure = x;
      }
    }    void show() {
      String result;
      if (connectFinish != 0) {
        result = Long.toString(connectFinish - connectStart) + "ms";
        show = true;
      }
      else if (failure != null) {
        result = failure.toString();
        show = false;
      }
      else {
        result = "Timed out";
        show = false;
      }
      ListenPortAndRestartService.println(address + " : " + result);
      shown = true;
    }  }  // Thread for printing targets as they're heard from
  //
  static class Printer
      extends Thread {
    LinkedList pending = new LinkedList();    Printer() {
      setName("Printer");
      setDaemon(true);
    }    void add(Target t) {
      synchronized (pending) {
        pending.add(t);
        pending.notify();
      }
    }    public void run() {      try {        for (; ; ) {
          Target t = null;
          synchronized (pending) {            while (pending.size() == 0) {
              pending.wait();
            }            t = (Target) pending.removeFirst();
          }
          t.show();
        }      }      catch (InterruptedException x) {
        return;
      }    }  }  // Thread for connecting to all targets in parallel via a single selector
  //
  static class Connector
      extends Thread {
    Selector sel;
    Printer printer;// List of pending targets.  We use this list because if we try to
// register a channel with the selector while the connector thread is
// blocked in the selector then we will block.
//
    LinkedList pending = new LinkedList();    Connector(Printer pr) throws IOException {
      printer = pr;
      sel = Selector.open();
      setName("Connector");
    }// Initiate a connection sequence to the given target and add the
// target to the pending-target list
//
    void add(Target t) {
      SocketChannel sc = null;
      try {// Open the channel, set it to non-blocking, initiate connect
        sc = SocketChannel.open();
        sc.configureBlocking(false);
        sc.connect(t.address);// Record the time we started
        t.channel = sc;
        t.connectStart = System.currentTimeMillis();// Add the new channel to the pending list
        synchronized (pending) {
          pending.add(t);
        }// Nudge the selector so that it will process the pending list
        sel.wakeup();      }
      catch (IOException x) {
        if (sc != null) {
          try {
            sc.close();
          }
          catch (IOException xx) {}
        }
        t.failure = x;
        printer.add(t);
      }
    }// Process any targets in the pending list
//
    void processPendingTargets() throws IOException {
      synchronized (pending) {
        while (pending.size() > 0) {
          Target t = (Target) pending.removeFirst();
          try {// Register the channel with the selector, indicating
// interest in connection completion and attaching the
// target object so that we can get the target back
// after the key is added to the selector's
// selected-key set
            t.channel.register(sel, SelectionKey.OP_CONNECT, t);          }
          catch (IOException x) {// Something went wrong, so close the channel and
// record the failure
            t.channel.close();
            t.failure = x;
            printer.add(t);          }        }
      }
    }// Process keys that have become selected
//
    void processSelectedKeys() throws IOException {
      for (Iterator i = sel.selectedKeys().iterator(); i.hasNext(); ) {// Retrieve the next key and remove it from the set
        SelectionKey sk = (SelectionKey) i.next();
        i.remove();// Retrieve the target and the channel
        Target t = (Target) sk.attachment();
        SocketChannel sc = (SocketChannel) sk.channel();// Attempt to complete the connection sequence
        try {
          if (sc.finishConnect()) {
            sk.cancel();
            t.connectFinish = System.currentTimeMillis();
            sc.close();
            printer.add(t);
          }
        }
        catch (IOException x) {
          sc.close();
          t.failure = x;
          printer.add(t);
        }
      }
    }    volatile boolean shutdown = false;// Invoked by the main thread when it's time to shut down
//
    void shutdown() {
      shutdown = true;
      sel.wakeup();
    }// Connector loop
//
    public void run() {
      for (; ; ) {
        try {
          int n = sel.select();
          if (n > 0) {
            processSelectedKeys();
          }
          processPendingTargets();
          if (shutdown) {
            sel.close();
            return;
          }
        }
        catch (IOException x) {
          x.printStackTrace();
        }
      }
    }  }  private static Printer printer;
  public static boolean pingRemoteHost(String hostName, int port) throws
      InterruptedException, IOException {
    Ping.port = port;// Create the threads and start them up
    if (printer == null) {
      printer = new Printer();
      printer.start();
    }    Connector connector = new Connector(printer);
    connector.start();// Create the targets and add them to the connector
    LinkedList targets = new LinkedList();
    Target t = new Target(hostName);
    targets.add(t);
    connector.add(t);// Wait for everything to finish
    Thread.sleep(300);
    connector.shutdown();
    connector.join();// Print status of targets that have not yet been shown
    for (Iterator i = targets.iterator(); i.hasNext(); ) {
      Target t1 = (Target) i.next();
      if (!t1.shown) {
        t.show();
      }
    }
    return Target.show;
  }
}
========================================================
文件太长，请合并下面的部分

Answer 10

class StreamGobbler
    extends Thread {
  InputStream is;
  String type;  StreamGobbler(InputStream is, String type) {
    this.is = is;
    this.type = type;
  }  public void run() {
    try {
      InputStreamReader isr = new InputStreamReader(is);
      BufferedReader br = new BufferedReader(isr);
      String line = null;
      while ( (line = br.readLine()) != null)
        ListenPortAndRestartService.println(type + ">" + line);
    }
    catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }
}public class ListenPortAndRestartService {
  private static String filePath = "/opt/jboss-3.2.6/server/default/deploy/myApplication.war/log";//"D:"; 
  public static void main(String[] args) throws InterruptedException {
    String filePathConfig = "/opt/ensureJBoss/restartJBossService.properties";//"D:\\dd.properties";
    String cmd1 = "sh";//"cmd.exe"; 
    String cmd2 = "-c";//"/C"; 
    String cmd31 = "/opt/jboss-3.2.6/bin/shutdown.sh -S";//"D:\\backup\\jboss-3.2.6\\bin\\shutdown.bat -S"; 
    String cmd32 = "export LD_LIBRARY_PATH=/opt/smslib";//"dir"; //
    String cmd33 = "/opt/jboss-3.2.6/bin/run.sh &";//"D:\\backup\\jboss-3.2.6\\bin\\run.bat"; //
    String ip = "localhost";
    int port = 8080;
    while (true) {
      boolean needListen = false;
      ListenPortAndRestartService listen = new ListenPortAndRestartService();
      String need = listen.getProperties(filePathConfig).getProperty(
          "needListen");
      if (need.equalsIgnoreCase("false")) {
        needListen = false;
      }
      else if (need.equalsIgnoreCase("true")) {
        needListen = true;
      }      while (needListen) {
        try {
          boolean pingResult = Ping.pingRemoteHost(ip, port);
          println("" + pingResult);
          if (!pingResult) {
            String osName = System.getProperty("os.name");
            println(osName);
            String[] cmd = new String[3];
            Date start = new Date();
            println(start + ":JBoss shutdown,need restart...........");
            println("First,shutdown...................");
            cmd[0] = cmd1;
            cmd[1] = cmd2;
            cmd[2] = cmd31;
            Runtime rt = Runtime.getRuntime();
            println("Execing " + cmd[0] + " " + cmd[1]
                    + " " + cmd[2]);
            Process proc = rt.exec(cmd);
            // any error message?
            StreamGobbler errorGobbler = new
                StreamGobbler(proc.
                              getErrorStream(),
                              "ERROR");            // any output?
            StreamGobbler outputGobbler = new
                StreamGobbler(proc.
                              getInputStream(),
                              "OUTPUT");            // kick them off
            errorGobbler.start();
            outputGobbler.start();            Thread.sleep(30000);
            println("Second,export...................");
            cmd[0] = cmd1;
            cmd[1] = cmd2;
            cmd[2] = cmd32;            rt = Runtime.getRuntime();
            println("Execing " + cmd[0] + " " + cmd[1]
                    + " " + cmd[2]);
            proc = rt.exec(cmd);
            // any error message?
            errorGobbler = new
                StreamGobbler(proc.getErrorStream(),
                              "ERROR");            // any output?
            outputGobbler = new
                StreamGobbler(proc.getInputStream(),
                              "OUTPUT");            // kick them off
            errorGobbler.start();
            outputGobbler.start();
            println(
                "Third,run........................");
            cmd[0] = cmd1;
            cmd[1] = cmd2;
            cmd[2] = cmd33;            rt = Runtime.getRuntime();
            println("Execing " + cmd[0] + " " + cmd[1]
                    + " " + cmd[2]);
            proc = rt.exec(cmd);
            // any error message?
            errorGobbler = new
                StreamGobbler(proc.getErrorStream(),
                              "ERROR");            // any output?
            outputGobbler = new
                StreamGobbler(proc.getInputStream(),
                              "OUTPUT");            // kick them off
            errorGobbler.start();
            outputGobbler.start();
            Date end = new Date();
            println(end + ":JBoss restart successful...........");
          }
          Thread.sleep(30000);
          need = listen.getProperties(filePathConfig).getProperty(
              "needListen");
          if (need.equalsIgnoreCase("false")) {
            needListen = false;
          }
          else if (need.equalsIgnoreCase("true")) {
            needListen = true;
          }
        }
        catch (Throwable t) {
          t.printStackTrace();
        }
      }      if (!needListen) {
        Thread.sleep(30000);
        println("service has been closed.............");
      }
    }
  }  static void println(String fileContent) {
    /**
     * 取得项目路径，如果路径不存在。则新建路径
     */    String fileName = "restartJBoss" +
        new SimpleDateFormat("yyyy-MM-dd").format(new
                                                  Date(System.currentTimeMillis())) +
        ".log";
    File path = new File(filePath);
    if (!path.exists()) {
      path.mkdir();
    }
    File file = new File(path, fileName);
    //如果文件长度大于10M,则改名成备份文件进行存储。
    if (file.length() > 10 * 1024 * 1024) {
      String rename = fileName +
          new SimpleDateFormat("yyyyMMddHHmmss").format(new
          Date(System.currentTimeMillis()));
      file.renameTo(new File(path, rename));    }
    try {
      byte[] temp = {
          10, 10};
      byte[] contentdb = fileContent.getBytes("gb2312");
      byte[] content = new byte[contentdb.length + temp.length];
      System.arraycopy(contentdb, 0, content, 0, contentdb.length);
      System.arraycopy(temp, 0, content, contentdb.length, temp.length);
      if (file.exists()) {
        //如果文件存在。则使用随机读写文件用RandomAccessFile类去定义到文件尾后写一条记录
        RandomAccessFile accessFile = null;
        accessFile = new RandomAccessFile(file, "rw");
        accessFile.seek(file.length());
        accessFile.write(content);
        accessFile.close();
      }
      else {
        //如果文件不存在。则使用写文件流一次性写入。
        FileOutputStream stream = new FileOutputStream(file);
        stream.write(content, 0, content.length);
        stream.close();
      }
    }
    catch (IOException ie) {
      ie.printStackTrace();
    }
  }  private Properties getProperties(String config) {
    Properties properties = new Properties();
    FileInputStream fileinputstream = null;
    try {
      fileinputstream = new FileInputStream(config);
    }
    catch (FileNotFoundException e) {
      println(e.getMessage());
    }
    try {
      if (fileinputstream != null) {
        properties.load(fileinputstream);
        fileinputstream.close();
      }
    }
    catch (IOException e) {
      println(e.getMessage());
    }
    return properties;
  }
}
========================================================
完

Answer 11

没有仔细看代码,想问一下,你是定时去执行ping操作么?

Answer 12

to laughsmile(海边的星空) :恩，定时ping8080端口，如果ping不通，就重启jboss

Answer 13

目前jboss运行情况又好了，真是搞不懂

Answer 14

你的程序中某部分有可能存在不能被垃圾回收的内存泄漏的问题,如果频繁运行到此部分,
运行了一段时间之后,jboss就down掉了.
要解决这个根本原因,就是review代码查看是否有资源没有释放.尤其是GC不能自动回收的资源没有释放

Answer 15

to laughsmile(海边的星空)：程序很简单，我检查过，不可能存在这种问题，不然就好解决了我用jboss仅仅是用作数据转发，不牵扯数据库，且运行正常的这段时间和异常的时候走的程序通路是一致的，不会存在你说的那种问题