QMutex and QDataStream

hi
i need to protect the access of a variable which is currently being filled with the QDataStream(in a multithreading program).

in the following code does the access of the int variable blocksize is locked or the datastream is locked ,or both.

Quote:

---

QDataStream datastream(socket);
QMutex mutex;
mutex.lock();
datastream >> blocksize;
mutex.unlock();

---

None. You don't lock variables.
The only thing you do here is that you make sure that the code line between lock() and unlock() is not executed by two or more threads at the same time. Nothing more.

Actually even that is not the case here as each thread will have its own mutex instance so they won't be exclusive. The above code is really a no-op (apart from the line operating on the stream).

thanks for u r replys

here is my header file.

//plot.h Include files are not specified to reduce the post size

Code:

---

class th : public QThread
{
	Q_OBJECT
 
public:
	th();
	void run();
 
	quint32 blocksize;
 
private slots:
	void read_socket();
 
private:
QTcpSocket *socket;
};
 
class PLOT : public QMainWindow
{
	Q_OBJECT
public:
	PLOT();
 
private:
	th t;
};
 
#endif /*PLOT_H_*/

---

//plot.cpp

Code:

---

th::th() :blocksize(0)
{
 
}
 
void th::run()
{
	socket=new QTcpSocket();
	socket->connectToHost("192.168.1.6", 9999);
	connect(socket, SIGNAL(readyRead()), this, SLOT(read_socket()));
	exec();
}
 
void th::read_socket()
{
	QDataStream in(socket);
	if (blocksize == 0)
	{
		if (socket->bytesAvailable() < (int)sizeof(quint32))
			return;
 
		in >> blocksize;
	}
}
 
PLOT::PLOT()
{
	t.start();
 
       //waiting here till the t.blocksize variable is getting filled but had not worked and never 
      //gets out of the loop,i have tried declaring the blocksize variable in the [B]th[/B] 
      //class as[B] volatile  quint32 blocksize[/B] and even it has not worked.
      //only [B]works[/B] when introduce a 
      //delay here as [B]QTest::qWait(3000);[/B]
 
     while (t.blocksize == (qint32)0)
	{
		qDebug()<<" PLOT inside while "<<t.blocksize;
		coloum=(int)(t.blocksize/360);
	}
}

---

where should i modify the code to work.

Read about QWaitCondition please.

If i have to use the QWaitCondition i have to use the mutex,which means i need two classes subclassed from QThread , and also i have to do gui in my program.i tried to use QWaitCondition but i am stuck,i am unable to figure where to wait and where to wakeup the thread(one of the class in the above program does not inherit QThread.)

Do i have to have multiple inheritance(QThread and QWidget ) to solve the above problem in which i have do both gui and threading.


why the above code never gets out of while.
here is a sample code

Code:

---

#include <QtGui>
#include <QtNetwork>
 
class trd : public QThread
{
public:
	void run()
	{
		while (1)
			qDebug()<<"run";
	}
};
 
class sub : public QWidget
{
public:
	sub()
	{
		trd th;
		th.start();
 
		while (1)
		qDebug()<<"sub";
	}
};
 
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	sub t;
	return a.exec();
}

---

in this code both the run and sub gets printed alternatively , the same idea i am using to make work in the program(waiting for the while condition to fail) in the above post.where did i made the error.

thanks

I don't really understand what you mean by "where to wait and where to wake"... Don't you know where you want to halt execution of one thread and when to let it run? It is your algoritm - you should know best.

Consider two classes class GUI(which subclasses QWidget) and class THD(which subclasses QThread) ,now if i want to wait in class G for a condition which is set by class THD ,what should i do.

here is a simple code what i have explained above.

Code:

---

#include <QtGui>
 
class THD : public QThread
{
public:
	int i;
 
	THD():i(0)
	{
 
	}
 
	void run()
	{
		i=1;
	}
};
 
class GUI : public QWidget
{
public:
	GUI()
	{
		THD th;
		th.start();
 
		//wait until i is changed and then continue(how to wait)
	}
};
 
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	GUI t;
	return a.exec();
}

---

Call wait() where you want to wait and wakeAll() where you want to release the other thread. What is the problem?

Code:

---

QMutex m;
QWaitCondition wc;
GUI(){THD th; th.start(); wc.wait(&m); }
...
void run(){ i=0; wc.wakeAll(); }

---

By the way, in this case you could easily use signals and slots instead of a mutex...

thanks wysota
But the widget is not getting displayed after adding the wc.wait(&m) (i have called show() in main). it seems that it gets stopped until the wc.wakeAll() is called .But i want it to wake according to the buttons pressed in the GUI widget.
should i have to start the thread in a slot.

Code:

---

in this case you could easily use signals and slots instead of a mutex

---

the above code is just to explain my problem . i am using the ideas in different program which is large to post here.

Quote:

---

Originally Posted by babu198649

it seems that it gets stopped until the wc.wakeAll() is called

---

Isn't that what you wanted? You wanted to stop execution of a thread until a variable is changed in another thread. That's exactly what happens.

Quote:

---

Quote:

---

in this case you could easily use signals and slots instead of a mutex

---

the above code is just to explain my problem . i am using the ideas in different program which is large to post here.

---

Then maybe you should try expressing your problems more clearly. If you describe your problem incorrectly, you can only blame yourself for getting a wrong answer. Without seeing your code I can only say "redesign code to use signals and slots and rely on the event queue for synchronization".

There is a server and a client program. Server should be started first and when the client gets connected to server, server sends array(floating values) of data through socket

The first four bytes of the data which is send through socket contains the total number of floating values(size of array).

here is the server program

//ss.h server program

Code:

---

#ifndef SS_H_
#define SS_H_
 
#include <QtGui>
#include <QtNetwork>
 
class SS:public QWidget
{
	Q_OBJECT
 
public:
	SS();
 
private slots:
	void send_data();
 
private:
	float *val_var;
	long val_var_size;
	QTcpServer *server;
 
};
 
#endif /*SS_H_*/

---

//ss.cpp

Code:

---

#include "ss.h"
#include <QtGui>
 
SS::SS()
{
	val_var_size=180000;
	val_var =new float[val_var_size];
	for (long i=0; i<val_var_size; i++)
	{
		*(val_var+i)=i;
		qDebug()<<*(val_var+i);
	}
 
	//send the data through socket
	server =new QTcpServer();
	if (!server->listen(QHostAddress::Any, 9999))
	{
		qDebug()<<"unable to listen to port";
		exit(1);
	}
	else
		qDebug()<<"Server is running ,Start the client";
 
	connect(server, SIGNAL(newConnection()), this, SLOT(send_data()));
}
 
void SS::send_data()
{
	QByteArray block;
	QDataStream out(&block, QIODevice::WriteOnly);
	out << (quint32)0;
 
	for (long i=0; i<val_var_size; i++)
		out<<*(val_var+i);
 
	//write the size of array in the first 4 bytes of data.
	out.device()->seek(0);
	out << (quint32)(val_var_size);
 
	QTcpSocket *socket = server->nextPendingConnection();
	connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));
	socket->write(block);
	socket->disconnectFromHost();
	qDebug()<<"ALL data has been send to socket..";
}
 
int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	SS s;
	return app.exec();
}

---

In the client program there is a seperate thread which reads the data from socket and stores in array, where as the main class(ie.class PLOT) reads the data stored in the array and starts to paint on the pixmap based on the array values.

The thread which works on the socket ,first stores the first four bytes(size of the array) in a variable.
The main class(ie.class PLOT) needs this value to decide, the number of polygons a circle should be split in to.And then based on the array values the polygons are painted with different colors.
So main class(ie.class PLOT) has to wait till the thread(th class) stores the first 4 bytes(size of array) .also the events (paint event) should not get blocked(ie.if a widget is created and showed it should get displayed even when the main class(class PLOT) is in wait state)

the waitconditions examples does array access but does not deal with any gui.



//plot.h client program

Code:

---

#ifndef PLOT_H_
#define PLOT_H_
 
#include <QtGui>
#include <QtNetwork>
 
class th : public QThread
{
	Q_OBJECT
 
public:
	th();
	void run();
 
	float *arr;
	quint32 blocksize;
	quint32 blocksize_check;
 
private slots:
	void read_socket();
 
private:
	QTcpSocket *socket;
 
};
 
class PLOT : public QMainWindow
{
	Q_OBJECT
 
public:
	PLOT();
 
protected:
	void paintEvent(QPaintEvent *);
	void wheelEvent(QWheelEvent * event);
	void mouseMoveEvent(QMouseEvent * event);
	void mousePressEvent(QMouseEvent *event);
 
private:
	th t;
 
	QVector<QPolygonF> pol;
	QPixmap pixmap;
	QPixmap pixmap_scaled;
 
	qreal zoomfactor;
 
	QPoint mouse_press;
	QPoint offset;
};
 
#endif /*PLOT_H_*/

---

//plot.cpp

Code:

---

#include "plot.h"
#include <QtTest>
#include <math.h>
 
#include <qwt_color_map.h>
#include <qwt_double_interval.h>
 
QMutex m;
QWaitCondition wc;
 
th::th() :
	blocksize(0), blocksize_check(0)
{
 
}
 
void th::run()
{
	socket=new QTcpSocket();
	socket->connectToHost("127.0.0.1", 9999);
	connect(socket, SIGNAL(readyRead()), this, SLOT(read_socket()));
	exec();
}
 
void th::read_socket()
{
	qDebug()<<"read_socket";
	QDataStream in(socket);
	if (blocksize == 0)
	{
		if (socket->bytesAvailable() < (int)sizeof(quint32))
			return;
 
		in >> blocksize;
 
		qDebug()<<"inside if";
 
		wc.wakeAll();
 
		arr=new float[blocksize];
		qDebug()<<"  block size "<<blocksize;
	}
 
	//fill the array which is accessed by the PLOT class later
	while (blocksize_check<blocksize)
	{
		in>>*(arr+blocksize_check);
		blocksize_check++;
	}
}
 
PLOT::PLOT() :
	zoomfactor(1)
{
	resize(800, 600);
	t.start();
 
	offset.setX(0);
	offset.setY(0);
 
	int degree=360;
	int coloum;
 
	wc.wait(&m);  // replacing with QTest::qWait(5000); makes work
	coloum=(int)(t.blocksize/360);
 
 
	qDebug()<<" PLOT  "<<t.blocksize<<"coloum  "<<coloum;
 
	while (t.blocksize == (qint32)0)
	{
		qDebug()<<" PLOT inside while "<<t.blocksize;
		coloum=(int)(t.blocksize/360);
	}
 
	//calculate the polygon points (a circle is split in to (degree*coloum) polygons)
	QPointF points[4];
	for (int i = 0; i<degree; i++)
	{
		for (int j=0; j<coloum; j++)
		{
			points[0].setX(j * cos(i*(3.14/180)));
			points[0].setY(j * sin(i*(3.14/180)));
 
			points[1].setX((j +1)* cos(i*(3.14/180)));
			points[1].setY((j +1)* sin(i*(3.14/180)));
 
			points[2].setX((j +1)* cos((i+1)*(3.14/180)));
			points[2].setY((j +1)* sin((i+1)*(3.14/180)));
 
			points[3].setX((j)* cos((i+1)*(3.14/180)));
			points[3].setY((j)* sin((i+1)*(3.14/180)));
 
			QVector<QPointF> vecp;
			for (int k=0; k<4; k++)
				vecp.append(points[k]);
 
			QPolygonF polygon(vecp);
			pol.append(polygon);
		}
	}
 
	QwtLinearColorMap colorMap(Qt::blue, Qt::red);
 
	//find min and max value to set the color value
	float min=0, max=0;
	for (int i=0; i<(int)t.blocksize; i++)
	{
		if (*(t.arr+i)>max)
			max=*(t.arr+i);
		if (*(t.arr+i)<min)
			min=*(t.arr+i);
		qDebug()<<*(t.arr+i)<<"  "<<i;
	}
	QwtDoubleInterval di(min, max);
 
	pixmap = QPixmap(coloum*2, coloum*2);
	pixmap.fill(Qt::transparent);
	QPainter painter(&pixmap);
	painter.setRenderHint(QPainter::Antialiasing, true);
	painter.translate(coloum, coloum);
 
	for (int i = 0; i<degree; i++)
	{
		for (int j=0; j<coloum; j++)
		{
			painter.save();
			painter.setBrush(QBrush(colorMap.color(di, *(t.arr +(coloum*i+j)))));
			painter.setPen(colorMap.color(di, *(t.arr+(coloum*i+j))));
 
			painter.drawPolygon(pol.at(coloum*i+j));
			painter.restore();
		}
	}
 
	pixmap_scaled=pixmap.scaled(1*pixmap.size());
}
 
void PLOT::paintEvent(QPaintEvent *)
{
	QPainter painter(this);
	painter.save();
	painter.drawPixmap(offset, pixmap_scaled);
 
	painter.restore();
}
 
void PLOT::wheelEvent(QWheelEvent * event)
{
	if (event->delta()>0)//if rotated forward delta() gives positive value
		zoomfactor=zoomfactor+0.055;
	else
		zoomfactor=zoomfactor-0.055;
 
	QSize oldsize = pixmap_scaled.size();
	pixmap_scaled=pixmap.scaled(zoomfactor*pixmap.size());
	QSize newsize= pixmap_scaled.size();
	QSize tempsize = (oldsize-newsize)/2;
 
	offset.setX(offset.x()+tempsize.width());
	offset.setY(offset.y()+tempsize.height());
 
	update();
}
 
void PLOT::mouseMoveEvent(QMouseEvent * event)
{
	offset=event->pos()-mouse_press+offset;
	mouse_press=event->pos();
 
	update();
}
 
void PLOT::mousePressEvent(QMouseEvent *event)
{
	mouse_press=event->pos();
}

---

//main.cpp

Code:

---

#include <QtGui>
#include "plot.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    PLOT p;
    p.show();
 
    return a.exec();
}

---

i have attached the same program with this post.

Note:The client program uses qwt-5.0.2 and hence it is required to run the application.
In the server program the values send through socket(array) are read from netcdf files and it requires its own libraries ,That is why i am sending incremental values through the socket.

If the gui reacts on the output from the worker thread, then the thread can emit a signal triggering a slot in the gui thread and running your code - no need for any special synchronisation mechanism.

And by the way, if your thread's only job is to read the network, then get rid of it and do that from the main thread.

I am unable to explain the problem clearly:(
Main class has a worker thread which gets the data from network and puts in array ,while at the same time Main thread uses the data to paint in a pixmap.

If u help in solving the below program my problem is over.
the GUI class is put to wait state .On press of the pushbutton the slot in the THREAD class wakes up all the thread.

please comment the 37th line of code and execute the program ,then a widget is displayed.If it is executed as it is the widget is not displayed.

the widgets should get displayed even if the 37th line is not commented(ie.even if the program is in wait state.)

Code:

---

#include <QtGui>
 
QMutex m;
QWaitCondition wc;
 
class THREAD : public QThread
{
	Q_OBJECT
 
public:
	void run()
	{
 
	}
 
public slots:
	void slot_run()
	{
		wc.wakeAll();
		qDebug()<<"wakeall..";
	}
};
 
class GUI : public QWidget
{
	Q_OBJECT
 
public:
	THREAD th;
	GUI()
	{
		resize(400,400);
		th.start();
 
		//only after commenting the below statement(wc.wait(&m)) the widget gets displayed, 
		//the widget should get displayed even when uncommented.
		wc.wait(&m);
		qDebug()<<"Wait is over...";
 
		QPushButton *button=new QPushButton("click",this);
		button->show();
 
		connect(button,SIGNAL(clicked()),&th,SLOT(slot_run()));
	}
};
 
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	GUI g;
	g.show();
	return a.exec();
}
 
#include "main.moc"

---

I found the following lines from Qt doc(http://doc.trolltech.com/4.3/threads.html).

Accessing QObject Subclasses from Other Threads
QObject and all of its subclasses are not thread-safe.

also it is said that

If you are calling a function on an QObject subclass that doesn't live in the current thread and the object might receive events, you must protect all access to your QObject subclass's internal data with a mutex;

does this mean the code in the above post can never be made work(without using signals and slots).

But you are not accessing any QObject from another thread... I think you have to change your way of thinking. Instead of thinking of the application as one linear flow, think of it as a state machine that is driven by the flow of events. Divide your application model into states and observe what needs to be done when changing states. You'll then be able to do everything in a single thread or in multiple threads but without any additional synchronization.