[Tomcat - FileUpload] - Inquiétude concernant la memoire du JVM

Bonjour tout le monde,
Vous allez bien ?
Apres avoir testé une application pendant plusieurs heures : mettre des images dans une base de donnée,via un navigateur (en passant par des JSP et servlet) j'ai eu la mauvaise surprise de découvrir le message suivant :

FileUpload java.lang.OutOfMemoryError: Java heap space

Donc j'ai fais plusieurs recherche et il s'averait que la JVM n'allouerait pas assez de mémoire.

Je vous donne d'abord ma config et ensuite jpasse au questions qui m'inquiete :
OS : Debian 3.1 (sarge)
Tomcat : 5.0.28
Java : 1.5_0_05b

1/ Maintnenant quand je fais java -Xmx256M, ca m'affiche toutes les commandes possible de java... bizarre ou normal ?

2/ Ensuite, y'a t'il moyen de savoir le total de mémoire allouer par la JVM ?

3/ Y'a t'il possibilité de savoir combien de mémoire disponible reste-t'il à la JVM à un instant donné ?

4/ Et pour finir, y'a t'il moyen de liberer l'espace JVM apres une action ? (parce que vous vous imaginez si un nombre important personnes upload chacune une image de 100k, la JVM risque de se remplir trop vite et y'a forcément une solution pour cela ?)

Je vous remercie d'avance,
Si vous avez aussi de la bonne doc sur cela (meme en anglais), ca serait sympa mais j'aimerais aussi avoir vos avis car la je suis dans le flou total au niveau de ce sujet.

Bonne journée.

++
ShinJava

Re: [Tomcat - FileUpload] - Inquietude de la memoire du JVM

Salut,

Citation:

Envoyé par ShinJava

1/ Maintnenant quand je fais java -Xmx256M, ca m'affiche toutes les commandes possible de java... bizarre ou normal ?

Si tu tapes seulement java -Xmx256M c'est normal puisqu'il s'attend a avoir un nom de classe à lancer...
Si comme je pense tu veux passer ce paramètre lors du démarrage de Tomcat, il faut que tu modifie la variable JAVA_OPTS du fichier catalina.sh (ou catalina.bat sous Windows) pour y ajouter -Xmx256m.
Source : http://tomcat.apache.org/faq/memory.html#adjust

Citation:

Envoyé par ShinJava

2/ Ensuite, y'a t'il moyen de savoir le total de mémoire allouer par la JVM ?

3/ Y'a t'il possibilité de savoir combien de mémoire disponible reste-t'il à la JVM à un instant donné ?

La classe Runtime doit répondre à cela...

Citation:

Envoyé par ShinJava

4/ Et pour finir, y'a t'il moyen de liberer l'espace JVM apres une action ? (parce que vous vous imaginez si un nombre important personnes upload chacune une image de 100k, la JVM risque de se remplir trop vite et y'a forcément une solution pour cela ?)

En Java il suffit de ne plus avoir aucune référence vers un objet pour qu'il soit 'nettoyé' par le Garbage Collector... Par contre tu ne peux pas vraiment forcer cela...

Mais je ne pense pas que l'upload de fichier de 100Ko puisse posé de tel problème...

Sur cette page tu as des détails sur les causes possibles de OutOfMemory : http://tomcat.apache.org/faq/memory.html#why

Plus généralement vérifie bien que tu ne conserves pas des références d'objet dont tu n'a plus l'utilité (en particulier si tu abuses des scopes session et application).
Vérifie également que tout tes flux soient bien fermés (fichier, connection JDBC, etc...).

a++

Salut,
Merci pour toute ces précisions ! Je commence à voir beaucoup plus claire.
Et effectivement dans les logs ya un Statement qui ne se ferme pas (jvais régler le probleme).
Huh je m'excuse d'avance de soliciter ton aide une nouvelle fois mais j'ai un petit souci dans le catalina.sh : je ne vois pas du tout où il faut modifier le JAVA_OPTS.
Dans ce cas la est ce que je fois faire :

set JAVA_OPTS= -Xms "40m " -Xmx "1536m " ??
Si oui, est-ce la bonne syntaxe et ou dois je le mettre (dsl c'est la premiere que je fais ca, et mes recherche sur le net n'ont pas abouti à grand chose).

Voici le fichier catalina.sh :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
 
#!/bin/sh
# -----------------------------------------------------------------------------
# Start/Stop Script for the CATALINA Server
#
# Environment Variable Prequisites
#
#   CATALINA_HOME   May point at your Catalina "build" directory.
#
#   CATALINA_BASE   (Optional) Base directory for resolving dynamic portions
#                   of a Catalina installation.  If not present, resolves to
#                   the same directory that CATALINA_HOME points to.
#
#   CATALINA_OPTS   (Optional) Java runtime options used when the "start",
#                   "stop", or "run" command is executed.
#
#   CATALINA_TMPDIR (Optional) Directory path location of temporary directory
#                   the JVM should use (java.io.tmpdir).  Defaults to
#                   $CATALINA_BASE/temp.
#
#   JAVA_HOME       Must point at your Java Development Kit installation.
#
#   JAVA_OPTS       (Optional) Java runtime options used when the "start",
#                   "stop", or "run" command is executed.
#
#   JPDA_TRANSPORT  (Optional) JPDA transport used when the "jpda start"
#                   command is executed. The default is "dt_socket".
#
#   JPDA_ADDRESS    (Optional) Java runtime options used when the "jpda start"
#                   command is executed. The default is 8000.
#
#   JSSE_HOME       (Optional) May point at your Java Secure Sockets Extension
#                   (JSSE) installation, whose JAR files will be added to the
#                   system class path used to start Tomcat.
#
#   CATALINA_PID    (Optional) Path of the file which should contains the pid
#                   of catalina startup java process, when start (fork) is used
#
# $Id: catalina.sh,v 1.13.2.1 2004/08/21 15:49:49 yoavs Exp $
# -----------------------------------------------------------------------------
 
# OS specific support.  $var _must_ be set to either true or false.
cygwin=false
os400=false
case "`uname`" in
CYGWIN*) cygwin=true;;
OS400*) os400=true;;
esac
 
# resolve links - $0 may be a softlink
PRG="$0"
 
while [ -h "$PRG" ]; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '.*/.*' > /dev/null; then
    PRG="$link"
  else
    PRG=`dirname "$PRG"`/"$link"
  fi
done
 
# Get standard environment variables
PRGDIR=`dirname "$PRG"`
 
# Only set CATALINA_HOME if not already set
[ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." ; pwd`
 
if [ -r "$CATALINA_HOME"/bin/setenv.sh ]; then
  . "$CATALINA_HOME"/bin/setenv.sh
fi
 
# For Cygwin, ensure paths are in UNIX format before anything is touched
if $cygwin; then
  [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
  [ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"`
  [ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"`
  [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
  [ -n "$JSSE_HOME" ] && JSSE_HOME=`cygpath --absolute --unix "$JSSE_HOME"`
fi
 
# For OS400
if $os400; then
  # Set job priority to standard for interactive (interactive - 6) by using
  # the interactive priority - 6, the helper threads that respond to requests
  # will be running at the same priority as interactive jobs.
  COMMAND='chgjob job('$JOBNAME') runpty(6)'
  system $COMMAND
 
  # Enable multi threading
  export QIBM_MULTI_THREADED=Y
fi
 
# Get standard Java environment variables
if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; then
  BASEDIR="$CATALINA_HOME"
  . "$CATALINA_HOME"/bin/setclasspath.sh
else
  echo "Cannot find $CATALINA_HOME/bin/setclasspath.sh"
  echo "This file is needed to run this program"
  exit 1
fi
 
# Add on extra jar files to CLASSPATH
if [ -n "$JSSE_HOME" ]; then
  CLASSPATH="$CLASSPATH":"$JSSE_HOME"/lib/jcert.jar:"$JSSE_HOME"/lib/jnet.jar:"$JSSE_HOME"/lib/jsse.jar
fi
CLASSPATH="$CLASSPATH":"$CATALINA_HOME"/bin/bootstrap.jar:"$CATALINA_HOME"/bin/commons-logging-api.jar
 
if [ -z "$CATALINA_BASE" ] ; then
  CATALINA_BASE="$CATALINA_HOME"
fi
 
if [ -z "$CATALINA_TMPDIR" ] ; then
  # Define the java.io.tmpdir to use for Catalina
  CATALINA_TMPDIR="$CATALINA_BASE"/temp
fi
 
# For Cygwin, switch paths to Windows format before running java
if $cygwin; then
  JAVA_HOME=`cygpath --absolute --windows "$JAVA_HOME"`
  CATALINA_HOME=`cygpath --absolute --windows "$CATALINA_HOME"`
  CATALINA_BASE=`cygpath --absolute --windows "$CATALINA_BASE"`
  CATALINA_TMPDIR=`cygpath --absolute --windows "$CATALINA_TMPDIR"`
  CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
  [ -n "$JSSE_HOME" ] && JSSE_HOME=`cygpath --absolute --windows "$JSSE_HOME"`
  JAVA_ENDORSED_DIRS=`cygpath --path --windows "$JAVA_ENDORSED_DIRS"`
fi
 
# ----- Execute The Requested Command -----------------------------------------
 
echo "Using CATALINA_BASE:   $CATALINA_BASE"
echo "Using CATALINA_HOME:   $CATALINA_HOME"
echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR"
echo "Using JAVA_HOME:       $JAVA_HOME"
 
if [ "$1" = "jpda" ] ; then
  if [ -z "$JPDA_TRANSPORT" ]; then
    JPDA_TRANSPORT="dt_socket"
  fi
  if [ -z "$JPDA_ADDRESS" ]; then
    JPDA_ADDRESS="8000"
  fi
  if [ -z "$JPDA_OPTS" ]; then
    JPDA_OPTS="-Xdebug -Xrunjdwp:transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=n"
  fi
  CATALINA_OPTS="$CATALINA_OPTS $JPDA_OPTS"
  shift
fi
 
if [ "$1" = "debug" ] ; then
 
  if $os400; then
    echo "Debug command not available on OS400"
    exit 1
  else
    shift
    if [ "$1" = "-security" ] ; then
      echo "Using Security Manager"
      shift
      exec "$_RUNJDB" $JAVA_OPTS $CATALINA_OPTS \
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
        -sourcepath "$CATALINA_HOME"/../../jakarta-tomcat-catalina/catalina/src/share \
        -Djava.security.manager \
        -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
        -Dcatalina.base="$CATALINA_BASE" \
        -Dcatalina.home="$CATALINA_HOME" \
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
        org.apache.catalina.startup.Bootstrap "$@" start
    else
      exec "$_RUNJDB" $JAVA_OPTS $CATALINA_OPTS \
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
        -sourcepath "$CATALINA_HOME"/../../jakarta-tomcat-catalina/catalina/src/share \
        -Dcatalina.base="$CATALINA_BASE" \
        -Dcatalina.home="$CATALINA_HOME" \
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
        org.apache.catalina.startup.Bootstrap "$@" start
    fi
  fi
 
elif [ "$1" = "run" ]; then
 
  shift
  if [ "$1" = "-security" ] ; then
    echo "Using Security Manager"
    shift
    exec "$_RUNJAVA" $JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
      -Djava.security.manager \
      -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
      -Dcatalina.base="$CATALINA_BASE" \
      -Dcatalina.home="$CATALINA_HOME" \
      -Djava.io.tmpdir="$CATALINA_TMPDIR" \
      org.apache.catalina.startup.Bootstrap "$@" start
  else
    exec "$_RUNJAVA" $JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
      -Dcatalina.base="$CATALINA_BASE" \
      -Dcatalina.home="$CATALINA_HOME" \
      -Djava.io.tmpdir="$CATALINA_TMPDIR" \
      org.apache.catalina.startup.Bootstrap "$@" start
  fi
 
elif [ "$1" = "start" ] ; then
 
  shift
  touch "$CATALINA_BASE"/logs/catalina.out
  if [ "$1" = "-security" ] ; then
    echo "Using Security Manager"
    shift
    "$_RUNJAVA" $JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
      -Djava.security.manager \
      -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
      -Dcatalina.base="$CATALINA_BASE" \
      -Dcatalina.home="$CATALINA_HOME" \
      -Djava.io.tmpdir="$CATALINA_TMPDIR" \
      org.apache.catalina.startup.Bootstrap "$@" start \
      >> "$CATALINA_BASE"/logs/catalina.out 2>&1 &
 
      if [ ! -z "$CATALINA_PID" ]; then
        echo $! > $CATALINA_PID
      fi
  else
    "$_RUNJAVA" $JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
      -Dcatalina.base="$CATALINA_BASE" \
      -Dcatalina.home="$CATALINA_HOME" \
      -Djava.io.tmpdir="$CATALINA_TMPDIR" \
      org.apache.catalina.startup.Bootstrap "$@" start \
      >> "$CATALINA_BASE"/logs/catalina.out 2>&1 &
 
      if [ ! -z "$CATALINA_PID" ]; then
        echo $! > $CATALINA_PID
      fi
  fi
 
elif [ "$1" = "stop" ] ; then
 
  shift
  FORCE=0
  if [ "$1" = "-force" ]; then
    shift
    FORCE=1
  fi
 
  "$_RUNJAVA" $JAVA_OPTS $CATALINA_OPTS \
    -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \
    -Dcatalina.base="$CATALINA_BASE" \
    -Dcatalina.home="$CATALINA_HOME" \
    -Djava.io.tmpdir="$CATALINA_TMPDIR" \
    org.apache.catalina.startup.Bootstrap "$@" stop
 
  if [ $FORCE -eq 1 ]; then
    if [ ! -z "$CATALINA_PID" ]; then
       echo "Killing: `cat $CATALINA_PID`"
       kill -9 `cat $CATALINA_PID`
    fi
  fi
 
elif [ "$1" = "version" ] ; then
 
    "$_RUNJAVA"   \
      -classpath "$CATALINA_HOME/server/lib/catalina.jar" \
      org.apache.catalina.util.ServerInfo
 
else
 
  echo "Usage: catalina.sh ( commands ... )"
  echo "commands:"
  if $os400; then
    echo "  debug             Start Catalina in a debugger (not available on OS400)"
    echo "  debug -security   Debug Catalina with a security manager (not available on OS400)"
  else
    echo "  debug             Start Catalina in a debugger"
    echo "  debug -security   Debug Catalina with a security manager"
  fi
  echo "  jpda start        Start Catalina under JPDA debugger"
  echo "  run               Start Catalina in the current window"
  echo "  run -security     Start in the current window with security manager"
  echo "  start             Start Catalina in a separate window"
  echo "  start -security   Start in a separate window with security manager"
  echo "  stop              Stop Catalina"
  echo "  stop -force       Stop Catalina (followed by kill -KILL)"
  echo "  version           What version of tomcat are you running?"
  exit 1
 
fi

Merci encore
++
ShinJava

Citation:

Envoyé par ShinJava

Dans ce cas la est ce que je fois faire :

set JAVA_OPTS= -Xms "40m " -Xmx "1536m " ??
Si oui, est-ce la bonne syntaxe et ou dois je le mettre (dsl c'est la premiere que je fais ca, et mes recherche sur le net n'ont pas abouti à grand chose).

Sous Unix/Linux il suffit de rajouter la ligne suivante dans le catalina.sh (après l'entête du fichier) :

Code:

JAVA_OPTS="-Xms40m -Xmx1536m"

La commande set ne doit être utilisé que sous Windows dans le .bat (car sous Unix/Linux set sert à afficher les variables d'environnement, pas à les définir) :

Code:

set JAVA_OPTS="-Xms40m -Xmx1536m"

Si tu veux tu peux même définir la variable avant de lancer tomcat (ce qui t'évite de modifier le fichier .sh ou .bat).

Et apparemment d'après l'entête tu peux utiliser CATALINA_OPTS à la place...

a++

Merci beaucoup pour cet indication !
Bon bah tout à l'air d'être ok maintenant, j'avais zappé la partie JVM et je vais me pencher dessus.

AdiGuba, je te remercie enormement pour ta patience et ta clarté au niveau de tes réponses. Ca fait vraiment plaisir.
Merci infiniment.

++
ShinJava