Ich habe diese Serverklasse erstellt, die einen Thread startet, wenn eine neue Verbindung eingeht. In einigen Fällen funktioniert dies in Ordnung, aber es ist nicht sehr stabil. Ich versuche zu lösen, wo es bricht. Mein Debugger erzählt mir etwas über qmutex. Wenn jemand das Problem erkennen kann. ty

Es verbindet sich mit dem Elternteil mit Signal & Slots und erhält auch Daten zurück.

Hier ist der Header:

#ifndef FORTUNESERVER_H
#define FORTUNESERVER_H

#include <QStringList>
#include <QTcpServer>
#include <QThread>
#include <QTcpSocket>
#include <string>
using namespace  std;


class FortuneServer : public QTcpServer
{
    Q_OBJECT

 public:
    FortuneServer(QObject *parent = 0);

public slots:


void procesServerString(string serverString);
void getStringToThread(string serverString);

protected:
void incomingConnection(int socketDescriptor);

private:
QStringList fortunes;

signals:

void procesServerStringToParent(string serverString);
void getStringToThreadSignal(string serverString);
};


class FortuneThread : public QObject
 {
Q_OBJECT

public:
FortuneThread(int socketDescriptor, QObject *parent);

public slots:

void getString();
void sendString(string sendoutString);

signals:

void error(QTcpSocket::SocketError socketError);
void fromThreadString(string serverString);
void finished();


private:
int socketDescriptor;
QString text;
QTcpSocket tcpSocket;
};

#endif

und cc:

#include <stdlib.h>
#include <QtNetwork>
#include "MeshServer.hh"
#include <iostream>
#include "TableView.hh"

using namespace  std;

FortuneServer::FortuneServer(QObject *parent)
: QTcpServer(parent)
{

}

void FortuneServer::procesServerString(string serverString){

emit procesServerStringToParent(serverString);

}
void FortuneServer::getStringToThread(string serverString){

emit getStringToThreadSignal(serverString);

}

void FortuneServer::incomingConnection(int socketDescriptor)
{


FortuneThread *serverthread = new FortuneThread(socketDescriptor, this);
//connect(&serverthread, SIGNAL(finished()), &serverthread, SLOT(deleteLater()));


QThread* thread = new QThread;

serverthread->moveToThread(thread);

connect(thread, SIGNAL(started()), serverthread, SLOT(getString()));
connect(serverthread, SIGNAL(fromThreadString(string)), this,        SLOT(procesServerString(string)));
connect(this, SIGNAL(getStringToThreadSignal(string)), serverthread, SLOT(sendString(string)));

connect(serverthread, SIGNAL(finished()), thread, SLOT(quit()));
connect(serverthread, SIGNAL(finished()), serverthread, SLOT(deleteLater()));
connect(serverthread, SIGNAL(finished()), thread, SLOT(deleteLater()));

thread->start();

}



FortuneThread::FortuneThread(int socketDescriptor, QObject *parent)
: QObject(parent), socketDescriptor(socketDescriptor)
{



}

void FortuneThread::getString()
{

if (!tcpSocket.setSocketDescriptor(socketDescriptor)) {
    emit error(tcpSocket.error());
    cout<<"socket error"<<endl;
    return;
}
//in part
if(!tcpSocket.waitForReadyRead(10000)){

    emit finished();
    return;
}
int joj = tcpSocket.bytesAvailable();
char inbuffer[1024];
tcpSocket.read(inbuffer,1024);
string instring;
instring = inbuffer;
instring.resize(joj);

emit fromThreadString(instring);

}   


void FortuneThread::sendString(string sendoutString)
{       


//out part
char buffer[1024];
int buffer_len = 1024;
int bytecount;

memset(buffer, '\0', buffer_len);


string outstring = sendoutString;



int TempNumOne= (int)outstring.size();

for (int a=0;a<TempNumOne;a++)
    {
        buffer[a]=outstring[a];
    }

QByteArray block;
block = buffer;



tcpSocket.write(block);
tcpSocket.disconnectFromHost();
tcpSocket.waitForDisconnected();
emit finished();
}

Dies ist von Eltern:

//server start

QHostAddress adr;
adr.setAddress( QString("127.0.0.1") );
adr.toIPv4Address();
quint16 port = 1101;

if (!server.listen( adr, port)) {
  QMessageBox::critical(this, tr("CR_bypasser"),
      tr("Unable to start the server: %1.")
      .arg(server.errorString()));
  close();
  return;
}

QString ipAddress;
ipAddress = server.serverAddress().toString();
statusLabel->setText(tr("The server is running on\n\nIP: %1\nport: %2\n\n"
  "Run the Fortune Client example now.")
  .arg(ipAddress).arg(server.serverPort()));

connect (&server, SIGNAL(procesServerStringToParent(string)), this,  SLOT(procesServerString(string))); 
connect (this, SIGNAL(StringToServer(string)), &server, SLOT(getStringToThread(string))); 

edit: was ich versuche zu tun:

Ich habe einen Client (Teil einer Spiel-Engine (Cryengine)), den ich zum Senden einer Reihe von Ingame-Koordinaten und einigen anderen Dingen mit einem Sockel erstellt habe, wie er in einem von mir zuvor angegebenen Link erstellt wurde. Das funktioniert ok Ich erhalte Daten auf "127.0.0.1" Port 1101. Jetzt muss ich nur noch diese Daten in meinem eigenen Programm auswerten, das diese TableView-Klasse hat, in der ich Koordinaten sammeln kann, die ich aus der Zeichenfolge erhalte, einige Daten aus Koordinaten aufrufen und Geben Sie dann diese neue Zeichenfolge über den Server an gameengine zurück. Im Spiel klicke ich auf Objekte, um deren Farbe zu erhalten. Mache daraus eine Zeichenfolge (die coor, entityid usw. enthält) und sende diese Zeichenfolge an den Server, der die aufgerufenen Informationen von TableView zurückgibt. Ich brauche nur diesen One-Way-Flow, nur einen Client, der Strings sendet. Ich bin mir nicht sicher über recv (hsock, buffer, buffer_len, 0). Ich vermute, der Knoten, der für das Senden der Zeichenfolge im Spiel verantwortlich ist, wartet auf die Rückgabe der Zeichenfolge. Dies ist eines meiner ersten Programme atm Ich bin wirklich verwirrt ...