Bonjour,

Je suis sur un projet (P2P, Thread et Socket) et je vais essayer de résumer rapidement et clairement mon problème :

Dans mon programme, je dois avoir un objet qui doit constamment être en écoute.
Mais il doit aussi pouvoir envoyer des messages.

Donc je code à peu près de cette manière :

while(true) {
//Instructions d´écoute
}

//Instructions d´envoi de messages.

Or, vu que la boucle est infini, les instructions d´envoi de message ne s´exécutent pas. Logique me direz-vous. ^^
Je voudrais savoir de quelle manière procéder pour avoir à la fois la boucle infinie, et pouvoir exécuter les envois de message.

Merci pour votre aide et désolé si je n´ai pas été très clair, demandez-moi pour plus de précisions.

il y a deux facon
la premiere est de faire l´ecoute dans un thread séparé. Ceci est assez moche dans le cas d´application pair a pair ou beaucoup de connexion simultané risquent d´etre ouverte.

La bonne solution est l´utilisation de la fonction select. Un article decrivant select en java est disponible sur:
http://www.javaworld.com/javaworld/jw-04-2003/jw-0411-select.html?page=2

Merci pour ta réponse. Je viens de lire la méthode avec select, et j´avoue que ça me semble bien compliqué par rapport au peu que j´ai vu en cours. Beaucoup de fonctions que nous n´avons jamais utilisé sont dans le code.

Est-ce que la 1ère méthode serait plus simple, même si ce n´est pas très optimal ? Car je débute dans les thread, et je m´emmêle vite.

Ou alors n´y aurait-il pas selon toi une autre méthode pour faire en sorte qu´un Pair puisse à la fois écouter et envoyer ?

merci.

Si tu as toujours un seul socket qui écoute et un seul qui peut envoyer des information ouvert à chaque instant (ou un faible nombre (que tu peut borner a priori)), alors la première méthode est aussi bien. Elle devient inefficace si tu écrit un serveur qui peut être connecté à un nombre arbitrairement grand de client.

il parlait d´un projet "P2P". En general, le nombre de connecté simultanément est elevé.

Oui, j´aurais bien aimé que ça soit un serveur, ça m´aurait facilité la tâche.
Là le problème c´est que l´utilisateur est à la fois serveur et client. J´aurais bien utilisé la méthode avec select, mais vu que l´on n´a pas vu cela en cours, le professeur trouverait cela suspect. ^^

"le professeur trouverait cela suspect. ^^ "

Pourquoi ? Il pourrait aussi se dire : "Enfin! un élève qui cherche un peu par lui même".

Ce qui ne veut pas dire d´ailleurs que les profs ne doivent rien enseigner, au contraire, mais ils ne peuvent pas tout faire.

si on devait se limiter a ce que les profs disent en cours...
La programmation est un sujet telement vaste que tu as plutot interet a demander, chercher par toi meme ect.

En 3eme année, un prof qui encadrait un mini projet nous encourageait presque a pomper du code.
"Si vous arrivez a utiliser des programmes fait par d´autre c´est du temps de gagner et ça veux dire que vous avez compris comment ça marche" (la citation n´est peut-etre pas exacte au mot pres mais le message est le meme)

Finalement, j´avais commencé à faire avec les select, mais j´me suis entretenu avec mon prof à ce sujet, et il m´a dit qu´il valait en fait mieux mettre l´écoute et l´envoi de message dans la boucle infinie.

Je lance donc 2 fois quasiment le même programme, sauf que pour le 1er, port d´écoute = 7001. Pour le 2nd, port d´écoute = 7002.

Finalement, j´ai un code du genre :

ServerSocket socketAccueil = new ServerSocket(port d´écoute)
while(true) {
Socket clientSocket = new Socket(port d´écoute du 2nd programme)

//Thread d´écoute
new Ecoute(socketAccueil.accept());

//Envoi de message
}

Mon problème, c´est que lorsque je lance un programme, il attend obligatoirement de recevoir un message avant de pouvoir envoyer son propre message.
Comment faire pour que je puisse à la fois être constamment en écoute, et pouvoir envoyer un message ?

Merci de votre aide.

Bon, je ne connais pas du tout la prog réseau ni le java mais as tu pensé à essayer un truc ds le genre :

while(1) // toujours
{
while(on recoit aucune informations)
{
// on peut envoyer ce qu´on doit envoyer
}
// on recoit les données
}

Bon, mais le soucis c´est que soit tu receveras des données, soit tu seras en train d´en envoyer : avec ma methode tu ne pourras pas faire les deux à la fois.
J´imagine que pour un P2P c´est genant mais dans ce cas je ne vois que les threads qui pourraient t´aider.

Quoi que, conceptuellement, tu peux très bien écrire quelque chose ds le genre

while(1)
{
//on recoit UN PEU de données
//on envoit UN PEU de données
}

Et au final, tu auras l´impression de faire les 2 en meme temps.
Après, reste à trouver une structure qui te permette d´envoyer et de recevoir des informations au compte goute.
Mais je pense que c´est faisable.
Il faut juste que tu divises tes informations, et qu´à l´itération T tu prépares les paqués à envoyer a l´itération T+1.
Et il faut bien sur penser la meme chose pour la reception de données : pouvoir "reconstruire" les données recues petit bout à petit bout.

Après je dis peu etre des betises hein, je n´ai aucune connaissance en prog réseau, mais bon, je m´ennuiyais :D
Bon courage à toi jeune jedi !

Usuellement pour regler ces problemes, on utilise plusieurs threads. Les threads d´écoute produisent des messages à un thread de traitement.
Du fait, ton thread de traitement est à même d´envoyer des message a n´importe quel moment pourvu qu´on lui donne les bons messages à traiter.

Merci pour votre aide, donc effectivement je vais devoir composer avec d´autres threads.

Encore merci.

Dans un script php pour faire du irc via les sockets, le type faisait aussi une boucle infinie pour afficher non-stop les posts.
Pour envoyer une info au server, il générait un fichier texte avec des instructeurs qui, lors de chaque bouclage était lues, executées puis supprimées du fichier. Donc pas analogie avec ce que le gars avait fait, on pourrait imaganer faire :

<fenetre>Ce que tu reçois</fenetre>
|
| fichier texte
|
<fenetre>Ce que tu veux envoyer</fenetre>

@++