Bonjour Bonjour

J'ai en main une application serveur tcp/ip (pas mon code source !) que je modifie à-ma-guise et j'ai un petit soucis avec ; En effet, après environ 6-7 heures d'uptime l'usage du processeur s'envole ( il passe d'environ 0-10% au démarrage du server, à 100% sur les deux coeurs ) mais celui de la RAM reste normal.
J'en ai parlé avec un ami, qui me disait que les threads en java mourraient après un certain temps .... est-ce vrai ? Ou qu'une exception non attrapée pouvait détruire le thread également.
Du coup j'ai ajouté au début du démarrage du serveur ceci:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
Thread.setDefaultUncaughtExceptionHandler((Thread t, Throwable e) -> {
                System.out.println(t.getName()+": "+e);
            });
En pensant que si jamais un thread avait un soucis j'aurais un petit log, mais que-dalle.
J'ai également un log des threads en cours que le serveur écrit dans un fichier chaque heure, mais ceci s'arrete soudainement.
Voici la classe qui lance les worker threads (Si jamais cela peut etre utile..):

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
package server;
 
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
public class TimerManager {
    private static TimerManager instance = new TimerManager();
    private ScheduledThreadPoolExecutor ses;
 
    public static TimerManager getInstance() {
        return instance;
    }
 
    public void start() {
        if (ses != null && !ses.isShutdown() && !ses.isTerminated()) {
            return;
        }
        final ThreadFactory thread = new ThreadFactory() {
            private final AtomicInteger threadNumber = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                final Thread t = new Thread(r);
                t.setName("Timermanager-Worker-" + threadNumber.getAndIncrement());
                return t;
            }
        };
        ses = new ScheduledThreadPoolExecutor(4, thread);
    }
 
    public boolean isExistent() {
        return ses != null;
    }
 
    public boolean isShutdown() {
        return ses.isShutdown();
    }
 
    public void stop() {
        ses.shutdownNow();
        ses = null;
    }
 
    public void unregister(Runnable r) {
        ses.remove(r);
    }
 
    public void executeNow(Runnable r) {
        ses.execute(r);
    }
 
    public ScheduledFuture<?> register(Runnable r, long repeatTime, long delay) {
        return ses.scheduleAtFixedRate(r, delay, repeatTime, TimeUnit.MILLISECONDS);
    }
 
    public ScheduledFuture<?> register(Runnable r, long repeatTime) {
        return ses.scheduleAtFixedRate(r, 0, repeatTime, TimeUnit.MILLISECONDS);
    }
 
    public ScheduledFuture<?> schedule(Runnable r, long delay) {
        return ses.schedule(r, delay, TimeUnit.MILLISECONDS);
    }
 
    public ScheduledFuture<?> scheduleAtTimestamp(Runnable r, long timestamp) {
        return schedule(r, timestamp - System.currentTimeMillis());
    }
 
    public void purgeTM() {
        ses.purge();
    }
}
étant donne que je n'ai aucune trace du problème, je suis ouvert à toute proposition qui ameliorerait l'uptime de ce serveur

merci

nico