comprendre strand, bind, etc..
bonjour,
J'essaie de comprendre les différents tutorial pour avoir un client et un server multithread asynchronique.
En gros j'aimerai que quand l'un ou l'autre envoie une infos, cela ouvre un thread jusqu'a ce que l'échange soit terminé pendant que d'autre échange(thread) soient donc possible asynchroniquement.
Donc j'ai chercher sur le net les différents examples... :
https://www.boost.org/doc/libs/1_77_...cho_server.cpp
https://www.bogotobogo.com/cplusplus...ronizing_C.php
https://think-async.com/Asio/boost_a...tuttimer5.html
(website non sécurisé) https://dens.website/tutorials/cpp-asio/multithreading
mais franchement je ne comprends pas vraiment la méthode.
disons qu'avec boost::asio, les classes ou fonctions peuvent avec 1 ou plus arguments, arguments qui peuvent être tel ou tel variable/constante et même en copiant un exemple d'un des tutos pour l'initialisation d'une fonction, je me retrouve quand même avec des erreurs si ce n'est des warnings.
mon dernier essaie est pour le code coté client, je m'inspire du echo server histoire d'avoir une info à envoyé pour tester si cela fonctionne avec le serveur et du timer pour la methode mais de toutes façon je ne compile pas, bref...
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
|
#ifndef MFCHANFLER_H
#define MFCHANDLER_H
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <WinSock2.h>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
using namespace std;
using boost::asio::ip::udp;
class handler
{
private:
udp::socket socket_;
udp::resolver resolver_;
udp::resolver::results_type endpoints_
= resolver_.resolve(udp::v4(), "127.0.0.1", "3333");
udp::endpoint server_endpoint;
boost::asio::io_context::strand m_strand;
public:
enum { max_length = 1024 };
char sdata_[max_length];
char rdata_[max_length];
handler(boost::asio::io_service& io)
:socket_(io), resolver_(io), m_strand(io)
{
m_strand.wrap(boost::bind(&handler::send, this));
m_strand.wrap(boost::bind(&handler::receive, this));
}
void send()
{
cout << "send something" << endl;
std::cin.getline(sdata_, max_length);
size_t sdata_length = std::strlen(sdata_);
socket_.async_send(boost::asio::buffer(sdata_, sdata_length), *endpoints_.begin());
m_strand.wrap(boost::bind(&handler::send, this));
}
void receive()
{
cout << "receive something" << endl;
socket_.async_receive(boost::asio::buffer(rdata_, max_length), server_endpoint);
cout << rdata_ << endl;
m_strand.wrap(boost::bind(&handler::receive, this));
}
};
#endif |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
int main()
{
try
{
boost::asio::io_context io;
handler h(io);
boost::thread t(boost::bind(&boost::asio::io_service::run, &io));
io.run();
t.join();
system("pause");
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
} |
Bref, est-ce que quelqu'un peut m'expliquer ou m'orienter vers un autre tutorial peut-être, je suis un peu perdu là.
merci.
edit: Je vais essayer de revoir des tutos simplement sur les threads pour adapter une classe thread pour les send et receive de l'exemple echo client/serveur.
de ce que j'ai compris le strand permet de gerer le coté asynchronique des thread, les organiser, pour qu'ils s'enchaines les uns après les autres mais la méthode avec bind m'échappe.(j'fais pas mal de trucs en même temps, c'est pas évident)
