Russian Qt Forum

Вообщем сервер рассылает данные в отдельный поток...

myserver.cpp

C++ (Qt)
#include "myserver.h"
 
MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
}
 
 
void MyServer::StartServer()
{
    if(!this->listen(QHostAddress::Any,1234))
    {
        qDebug() << "Could not start server";
        thread = new MyThread(this);
        connect(thread, SIGNAL(finished()),thread, SLOT(deleteLater()));
        thread->start();
    }
    else
    {
        qDebug() << "Listening...";
    }
}
 
void MyServer::incomingConnection(int socketDescriptor)
{
    qDebug() << socketDescriptor << " Connecting...";
    thread->newConnection(socketDescriptor);
 
}
 

Mythread.cpp

C++ (Qt)
#include "mythread.h"
 
MyThread::MyThread( QObject *parent) :
    QThread(parent)
{
    blockSize = 0;
//    socket = new QTcpSocket(this);
}
 
void MyThread::run()
{
    //thread starts here
    qDebug() <<  " Starting thread";
//    socket = new QTcpSocket();
//    if(!socket->setSocketDescriptor(this->socketDescriptor))
//    {
//        emit error(socket->error());
//        return;
//    }
 
//    connect(socket,SIGNAL(readyRead()),this,SLOT(readyRead()),Qt::DirectConnection);
//    connect(socket,SIGNAL(disconnected()),this,SLOT(disconnected()),Qt::DirectConnection);
//    sockets.append(socket);
//    qDebug() << socketDescriptor << " Client Connected";
 
    exec();
}
void MyThread::newConnection(int sockDesc)
{
    qDebug() << sockDesc << " Client Connected";
    QTcpSocket *socket = new QTcpSocket();
    if(!socket->setSocketDescriptor(sockDesc))
       {
           emit error(socket->error());
           return;
       }
  connect(socket,SIGNAL(readyRead()),this,SLOT(readyRead()),Qt::DirectConnection);// падает тут 
    connect(socket,SIGNAL(disconnected()),this,SLOT(disconnected()),Qt::DirectConnection);
    sockets.append(socket);
 
 
 
}
 
void MyThread::readyRead()
{
 
     QString message;
     for(int i=0; i<sockets.size(); i++)
      {
          while(sockets[i]->bytesAvailable())
        {
            QDataStream in(sockets[i]);
          in.setVersion(QDataStream::Qt_4_7);
 
          if (blockSize == 0) {
            if (sockets[i]->bytesAvailable() < (int)sizeof(quint32))
                return;
          in >> blockSize;
        }
 
        if (sockets[i]->bytesAvailable() < blockSize)
          return;
 
          in>>message;
         }
     blockSize=0;
     }
     text = message;
     qDebug() << socketDescriptor << " Data in: " << message;
     SendData();
}
 
void MyThread::disconnected()
{
    for (int i=0; i<sockets.size(); i++)
                if (sockets[i]->state()!=QAbstractSocket::ConnectedState)
                {
                    qDebug() << sockets[i]->socketDescriptor() << "Disconnected";
                    sockets[i]->deleteLater();
                    sockets.removeAt(i);
                }
    if(sockets.empty())
      exit(0);
}
void MyThread::SendData()
{
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_7);
    out << (quint32)0;
    out << text;
    out.device()->seek(0);
    out << (quint32)(block.size() - sizeof(quint32));
    for(int i=0; i<sockets.size(); i++)
        sockets[i]->write(block);
}
 

Не могу понять, в закомменченной строке "падает тут" происходит ошибка сегментации SEGSIG fault, вроде для сокета память выделена и для потока, в чём же дело?

У тебя после ошибки "Could not start server" создаётся поток чтения, а если ошибки нет, то он не создаётся. По-мойму тут что-то должно быть наоборот :)

Непонятно зачем тебе поток - все у тебя происходит в главном потоке, а дополнительный просто eventLoop гоняет

Да и сокет в случае ошибки ты тож не удаляешь - так и висит он в утекшей памяти))

Отдельный поток только в run ? а то что просто поток гоняется и если кто-то подключился обрабатывается...

Сейчас вся обработка сигналов от сокета происходит в том же потоке, в котором крутится сервер

почему? типо отдельный поток только в методе run? а класс QThread на самом деле не весь в отдельном потоке?

Ага, QThread - это просто класс, управляющий потоком. В новом треде выполняется только метод run() и все, что вызвано из него непосредственно

Ладно, хорошо тогда принимать буду в основном потоке, а рассылать хочу всем клиентам в отдельном потоке пытаюсь это сделать следующим образом:

Myserver.cpp

C++ (Qt)
#include "myserver.h"
 
MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
    client = new QTcpSocket();
    blockSize = 0;
}
 
 
void MyServer::StartServer()
{
    if(!this->listen(QHostAddress::Any,1234))
    {
        qDebug() << "Could not start server";
 
    }
    else
    {
        qDebug() << "Listening...";
    }
}
 
void MyServer::incomingConnection(int socketDescriptor)
{
    qDebug() << socketDescriptor << " Connecting...";
        if(!client->setSocketDescriptor(socketDescriptor))
        {
//            emit error(client->error());
            return;
        }
 
        connect(client,SIGNAL(readyRead()),this,SLOT(ReceiveData()),Qt::DirectConnection);
        connect(client,SIGNAL(disconnected()),this,SLOT(disconnected()),Qt::DirectConnection);
        sockets.append(client);
        qDebug() << socketDescriptor << " Client Connected";
}
void MyServer::ReceiveData()
{
    QString message;
    for(int i=0; i<sockets.size(); i++)
     {
         while(sockets[i]->bytesAvailable())
       {
           QDataStream in(sockets[i]);
         in.setVersion(QDataStream::Qt_4_7);
 
         if (blockSize == 0) {
           if (sockets[i]->bytesAvailable() < (int)sizeof(quint32))
               return;
         in >> blockSize;
       }
 
       if (sockets[i]->bytesAvailable() < blockSize)
         return;
 
         in>>message;
        }
    blockSize=0;
    }
    text = message;
    qDebug() <<  " Data in: " << message;
    thread = new MyThread(sockets, text);
    connect(thread, SIGNAL(finished()),thread, SLOT(deleteLater()));
    thread->start();
}
void MyServer::disconnected()
{
    for (int i=0; i<sockets.size(); i++)
                if (sockets[i]->state()!=QAbstractSocket::ConnectedState)
                {
                    qDebug() << sockets[i]->socketDescriptor() << "Disconnected";
                    sockets[i]->deleteLater();
                    sockets.removeAt(i);
                }
}
 

MyThread.cpp

C++ (Qt)
#include "mythread.h"
 
MyThread::MyThread(QList <QTcpSocket *> clients, QString mes, QObject *parent) :
    QThread(parent)
{
    sockets = clients;
    text = mes;
}
 
void MyThread::run()
{
    //thread starts here
    qDebug() <<  " Starting thread";
    if(sockets.isEmpty())
        exit(0);
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_7);
    out << (quint32)0;
    out << text;
    out.device()->seek(0);
    out << (quint32)(block.size() - sizeof(quint32));
    for(int i=0; i<sockets.size(); i++)
        sockets[i]->write(block);
    exec();
}
 

в итоге получаю:

Listening...
264  Connecting...
264  Client Connected
 Data in:  "fgd"
 Starting thread
QObject: Cannot create children for a parent that is in a different thread.
(Parent is QNativeSocketEngine(0x5d4d48), parent's thread is QThread(0x5d2e28), current thread is MyThread(0x5d6458)

ты создал сокет в одном потоке, а используешь в другом. Внутренние объекты сокета противятся такому.

да и идея создать один сокет, а потом засовывать его в массив несколько раз, как будто их много, тоже не особо хороша

а как же мне тогда в отдельном потоке разослать всем клиентам данные?

Ну например можно мувнуть сокет в нужный тред. Или создать его прям в нужном треде

ну и еще - тред у тебя не умрет никогда, а на каждую новую порцию данных будет создан новый

А может посмотреть на существующие решения в плане организации межпроцессного общения и соответствующим протоколам?
Либо сервер должен в само приложения встраиваться наряду с клиентом?

Можно ссылки по этому поводу пожалуйста...?

Не совсем понял вопрос. Клиент отдельно, сервер отдельно. Сервер принимает данные от какой-нибудь клиента и отсылает их всем клиентам. То есть он нужен чтобы разослать данные от каждого клиента каждому клиенту, т.е. для взаимодействия клиентов каждый с каждым.

Имеешь в виду для каждого сокета отдельный поток что ли? Типо сокет подключился, создали для него поток... Я то хотел один поток для передачи всем сокетам (клиентам), поэтому в поток передаю список клиентов.  Кстати почему-то лист клиентов нельзя мувнуть в поток... почему? Чот я до конца не пойму, это получается поток может использовать только объекты созданные внутри него или как ?

что значит "мувнуть лист клиентов"?
нет, поток может и другие объекты использовать, но родитель объекта и сам объект должны находиться в одном и том же потоке

можно и один поток на весь список клиентов, просто лучше сокеты для этих клиентов прям в потоке создавать. Кстати, сокет у тебя сейчас только один, независимо от количества клиентов, что неправильно

Если сервер отдельно, то гораздо проще. На вскидку:

• protobuf
• CORBA (тот еще монстр конечно)
• Thrift
• AMQP и один из серверов его поддерживающих (RabbitMQ, QPID, ZeroMQ)

ИМХО рекомендовал бы присмотреться к последнему варианту, производительность у этого решения более чем достаточная, позволяет очень гибкие схемы обмена данными делать. Есть обертки для интеграции в Qt окружение для некоторых из них.

Пример описывающие идеологию AMQP можно посмотреть тут: http://www.rabbitmq.com/getstarted.html и тут http://www.rabbitmq.com/tutorials/amqp-concepts.html

вот это  QList <QTcpSocket *> clients как moveToThread сделать? по одному только что ли мувать?

чот блин с такими ограничению по использованию объектов мне даже пока норм идей не пришло как сделать чтобы  можно было получать от всех клиентов данные и отправлять всем клиентам данные в отдельном потоке, ну или хотя бы только отправлять в отдельном потоке а получать в главном

да, только по одному.
Вот тебе идея - создаешь объект, умеющий работать с сокетами. создаешь тред. муваешь этот объект в тред. в методе void MyServer::incomingConnection(int socketDescriptor) сигналом передаешь этому объекту socketDescriptor. Объект принимает дескриптор и создает для него сокет. А дальше объект вычитывает данные из сокетов, и отправляет через них же ответы клиентам

объект, умеющий работать с сокетами - сервер что ли, тобишь объект от него наследованный?

Нет, просто наследник QObject с нужными методами и слотами (для приема данных от сокета, для отправки данных через сокет)

Извини за тугодумство  ;D, но чот я не догнал зачем QObject здесь? можно насчёт этого попдробнее с примерчиком кода?)_)

QObject тут для того, чтобы у объекта были сигналы и слоты. Иначе как с ним общаться из другого треда?

ну сокет же сам как объект, да и тред тоже объект

Блин, ну не нравится - делай по-своему, я же не заставляю

я просто примерчик прошу чтобы понятнее было

C++ (Qt)
class Replyer: public QObject
{
	Q_OBJECT
public:
	Replyer(QObject *parent = 0) :QObject(parent) {}
 
private:
	QList<QTcpSocket*> mClients;
	void reply(QString message);
 
public slots:
	void newConnection(int descriptor);
 
private slots:
	void readData();
};
 
void Replyer::newConnection(int descriptor)
{
	QTcpSocket *client = new QTcpSocket(this);
	if(client->setSocketDescriptor(descriptor))
	{
		connect(client, SIGNAL(readyRead()), SLOT(readData()));
		mClients.append(client);
	}
	else
	{
		client->deleteLater();
	}
}
 
void Replyer::readData()
{
	QTcpSocket *client = qobject_cast<QTcpSocket*>(sender());
	if(client)
	{
		//read data from socket
		reply(...);
	}
}
 
void Replyer::reply(QString message)
{
	foreach(QTcpSocket* client, mClients)
	{
		//send data to clients
	}
}

вот приблизительно так я вижу класс, который будет жить в потоке. Удаление сокетов при отключении добавь по вкусу))

Писал не компилируя, могуть быть синтаксические ошибки

А как теперь с потоком связать это?
Я думаю так может: В класс потока добавить этот объект Replyer.  В классе сервера на incomingConnection добавить в поток в объект Replyer подключившийся сокет, передав ему дескриптор сокета. Но тогда что должно выполняться в потоке в методе run ?

QThread *thread = new QThread(this);
Replyer *repl = new Replyer();
repl->moveToThread(thread);
thread->run();

и кончено же к newConnection(int descriptor) надо прявязываться без Qt::DirectConnection

Спасибо, а что в методе run в потоке делать?

ничего. не перегружай поток, а используй стандартный QThread

спасибо вроде сделал, посмотри пожалуйста норм вышло?

replyer.h, replyer.cpp

C++ (Qt)
#include <QObject>
#include <QtNetwork>
#include <QDebug>
 
class Replyer : public QObject
{
    Q_OBJECT
public:
    explicit Replyer(QObject *parent = 0);
 
private:
        QList<QTcpSocket*> mClients;
        void reply(QString message);
        QString text;
        int blockSize;
 
 
public slots:
        void newConnection(int descriptor);
        void newDisconnection(); //смешное  название получилось :)
 
private slots:
        void readData();
 
};
 
 
#include "replyer.h"
 
Replyer::Replyer(QObject *parent) :
    QObject(parent)
{
    blockSize = 0;
}
 
void Replyer::newConnection(int descriptor)
{
            QTcpSocket *client = new QTcpSocket(this);
            if(client->setSocketDescriptor(descriptor))
            {
                    connect(client, SIGNAL(readyRead()), SLOT(readData()));
                    connect(client,SIGNAL(disconnected()),SLOT(newDisconnection()));
                    mClients.append(client);
            }
            else
            {
                    client->deleteLater();
            }
}
void Replyer::newDisconnection()
{
 
    foreach(QTcpSocket *client, mClients)
    {
        if (client->state()!=QAbstractSocket::ConnectedState)
            {
               qDebug() << client->socketDescriptor() << " Client Disconnected";
               mClients.removeOne(client);
               client->deleteLater();
            }
    }
}
 
void Replyer::readData()
{
    QTcpSocket *client = qobject_cast<QTcpSocket*>(sender());
 
    QString message;
         while(client->bytesAvailable())
       {
           QDataStream in(client);
         in.setVersion(QDataStream::Qt_4_7);
 
         if (blockSize == 0) {
           if (client->bytesAvailable() < (int)sizeof(quint32))
               return;
         in >> blockSize;
       }
 
       if (client->bytesAvailable() < blockSize)
         return;
 
         in>>message;
        }
    blockSize = 0;
    text = message;
    qDebug() << message;
    reply(message);
}
 
void Replyer::reply(QString message)
{
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_7);
    out << (quint32)0;
    out << message;
    out.device()->seek(0);
    out << (quint32)(block.size() - sizeof(quint32));
    foreach(QTcpSocket* client, mClients)
      {
          client->write(block);
      }
}
 

MyServerh, MyServer.cpp

C++ (Qt)
#include <QtNetwork/QTcpServer>
#include <QDebug>
#include "replyer.h"
 
class MyServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = 0);
    void StartServer();
protected:
    void incomingConnection(int socketDescriptor);
signals:
    void newClient(int socketDescriptor);
private:
    Replyer *replyer;
};
 
#include "myserver.h"
 
MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
    replyer = new Replyer();
    connect(this, SIGNAL(newClient(int)), replyer, SLOT(newConnection(int)));
    QThread *thread = new QThread(this);
    connect(thread,SIGNAL(finished()),thread,SLOT(deleteLater()));
    replyer->moveToThread(thread);
    thread->start();
}
 
void MyServer::incomingConnection(int socketDescriptor)
{
    qDebug() << socketDescriptor << " Client Connected";
    emit newClient(socketDescriptor);
}
 
void MyServer::StartServer()
{
    if(!this->listen(QHostAddress::Any,1234))
    {
        qDebug() << "Could not start server";
 
    }
    else
    {
        qDebug() << "Listening...";
    }
}
 

вроде должно работать. вот только читаешь ты все куски данных в один массив, так что если несколько клиентов одновременно пришлют данные, то их данные тупо смешаются

Хмм... кстати я тоже об этом думал, но когда пытался быстро слать от 2 клиентов сообщения с разных компов, то вроде всё норм, но вроде бы потенциально может прийти клиентам какая-нибудь фигня смешанная. А как эту проблему пофиксить? Завести какую-то очередь сообщений что ли?

то есть клиент прислал сообщение его в очередь, а потом пока очередь не пуста отсылать эти сообщения клиентам, может так ?

Да просто заведи на каждого клиента свой blockSize

а идея с очередью не катит?)

Не знаю, имхо излишне, хеша вида <сокет, blockSize> хватит с головой. Но можешь попробовать и очередь:)

сделал очередь, но не знаю как проверить работает ли...

И я не знаю. Это ж вероятная ситуация. Вызвать ее специально довольно сложно. проблема у тебя даже не в перемешивании данных, а в том, что blockSize ты прочитаешь из одного сокета, потом выйдешь из функции, а в следующий раз зайдешь уже когда сигнал будет от другого сокета и читать будешь уже не то, что ожидал

Но это только для 1-ого клиента  :)