Re: How to properly exit a thread?

["Xiangfei Jia" <xjianz gmail com>]

Hi, Paul:

I'm writing a GUI for monitoring system memory and swap disks.
Basically, I created a thread to read the "/proc/meminfo" continueously
and put new data into the customised DrawingArea class to plot memory
graph every second. 

It works like everytime the thread read a new data, the thread will
wait until the customised DrawingArea class finished ploting the new
data and then signal the thread to read more data. 

I haven't used gtkmm for long, and not so clear about how to use
gtkmm-wrapped threads. I tried to used your method, still now working.
Probably, I didn't use it properly.

I did like this:
try {

    Glib::Thread *const read =       Glib::Thread::create(sigc::mem_fun(node, &FrameNode::read_new_data), false);
 } catch(Glib::Thread::Exit&) {
   // Just exit from the thread.  The Thread::Exit exception
   // is our sane C++ replacement of g_thread_exit().
 }
 catch(...)
 {
   Glib::exception_handlers_invoke();
 }

To make things clear, I attated my source code.

Thanks!!! 

Fei
#ifndef FRAMENODE_H
#define FRAMENODE_H

#include <gtkmm.h>
#include <fstream>
#include "DisplayPlot.h"

class FrameNode : public Gtk::Frame {

public:
    FrameNode(char *);
    ~FrameNode();
    Gtk::HBox hbox_top;
    Gdk::Color temp_;
    DisplayPlot *plot_mem;
    DisplayPlot *plot_swap;

	Glib::Mutex mutex_;
	Glib::Cond cond_drawing_;

	void read_new_data();
	bool update_plot();

private:
    Gtk::Label *label_mem_total, *label_mem_free, *label_mem_used;
    Gtk::Label *label_swap_total, *label_swap_free;
	bool finished_drawing;
	bool finished_adding_new_data;
	char filename[100];
};

#endif

#include "FrameNode.h"
#include <libglademm/xml.h>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <cstdlib>

FrameNode::FrameNode(char *fname) :
    hbox_top(false, 0)
{
    set_label(" Hostname: Local ");
    //set_shadow_type(Gtk::SHADOW_OUT);
    //set_border_width(10);
    Glib::RefPtr<Gnome::Glade::Xml> refXml = Gnome::Glade::Xml::create("./monitor-temp.glade");
    Gtk::EventBox *eventbox;
    refXml->get_widget("eventbox1", eventbox);

	eventbox->reparent(*this);

	//plot mem
	plot_mem = Gtk::manage(new DisplayPlot);
    Gtk::VBox *vbox_plot;
	refXml->get_widget("vbox_plot_mem_container", vbox_plot);
	vbox_plot->pack_start(*plot_mem, Gtk::PACK_SHRINK, 0);

	refXml->get_widget("label_mem_total", label_mem_total);
	refXml->get_widget("label_mem_free", label_mem_free);
	refXml->get_widget("label_mem_used", label_mem_used);

	//plot swap
	plot_swap = Gtk::manage(new DisplayPlot);
	refXml->get_widget("vbox_plot_swap_container", vbox_plot);
	vbox_plot->pack_start(*plot_swap, Gtk::PACK_SHRINK, 0);

	refXml->get_widget("label_swap_total", label_swap_total);
	refXml->get_widget("label_swap_free", label_swap_free);

	strcpy(filename, fname);
	finished_drawing = true;
	finished_adding_new_data = false;
	Glib::signal_timeout().connect(sigc::mem_fun(*this, &FrameNode::update_plot), 1000);


}

void FrameNode::read_new_data() {
    using namespace std;

    static int count = 1100000;

	while(1) {

		string line;
		string str01, str02;
		unsigned long value_mem_total = 0, value_mem_free = 0, value_mem_used = 0;
		unsigned long value_swap_total = 0, value_swap_free = 0;
		ifstream inFile(filename);

		if (inFile) {
			while (!inFile.eof()) {
				getline(inFile, line);
				istringstream inStr(line);
				inStr >> str01;
				if (str01.compare("Total") == 0) {
				  inStr >> str02 >> value_mem_total;
				} else if (str01.compare("Used") == 0) {
				  inStr >> str02 >> value_mem_used;
				} else if (str01.compare("SwapTotal:") == 0) {
				  inStr >> value_swap_total;
				} else if (str01.compare("SwapFree:") == 0) {
					inStr >> value_swap_free;
				}
			}
			inFile.close();
		} else {

		}

		std::string outBuffer;
		std::ostringstream outStr(outBuffer);

		std::string text;
		//value_mem_total
		outStr << value_mem_total << "KB";
		label_mem_total->set_text(outStr.str());
		//value_mem_free
		value_mem_free = value_mem_total - value_mem_used;
		outStr.str("");
		outStr << value_mem_free << "KB";
		label_mem_free->set_text(outStr.str());
		//value_mem_used
		outStr.str("");
		//used_mem_percentage
		int used_mem_percentage = (int)((double)value_mem_used/value_mem_total * 100);
		outStr << used_mem_percentage << "%";
		label_mem_used->set_text(outStr.str());

		//value_swap_total
		outStr.str("");
		outStr << value_swap_total << "KB";
		label_swap_total->set_text(outStr.str());
		//value_swap_free
		outStr.str("");
		outStr << value_swap_free << "KB";
		label_swap_free->set_text(outStr.str());
		//used_swap_percentage
		int value_swap_used = value_swap_total - value_swap_free;
	int used_swap_percentage = (int)((double)value_swap_used/value_swap_total * 100);

		//add new data into the plot array
		mutex_.lock();
		if (finished_drawing == false) {
			cond_drawing_.wait(mutex_);
		}
		plot_mem->add_new_data(used_mem_percentage);
		plot_swap->add_new_data(used_swap_percentage);
		finished_drawing = false;
		finished_adding_new_data = true;
		mutex_.unlock();
		count++;
	}

}


bool FrameNode::update_plot() {


	if (finished_adding_new_data == true) {
		plot_mem->plot_graph();
		plot_swap->plot_graph();
		finished_drawing = true;
		finished_adding_new_data = false;
		cond_drawing_.signal();
	}

	return true;
}


FrameNode::~FrameNode() {

}


#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <gtkmm.h>
#include "FrameNode.h"
#include <fstream>

class MainWindow : public Gtk::Window {

public:
       MainWindow(char *);
       ~MainWindow();
       FrameNode *node;
protected:
        Gtk::VBox vbox_top;
		Gtk::HBox hbox_top;


};

#endif


#include "MainWindow.h"
#include <iostream>

MainWindow::MainWindow(char *fname) :
    vbox_top(false, 0),
    hbox_top(false, 0)
{
    node = Gtk::manage(new FrameNode(fname));
    hbox_top.pack_start(*node, Gtk::PACK_SHRINK);
	vbox_top.pack_start(hbox_top, Gtk::PACK_SHRINK);
    add(vbox_top);

	Glib::Thread *const read = Glib::Thread::create(sigc::mem_fun(node, &FrameNode::read_new_data), false);

	try {
	  Glib::Thread *const read = Glib::Thread::create(sigc::mem_fun(node, &FrameNode::read_new_data), false);
	} catch(Glib::Thread::Exit&) {
	  // Just exit from the thread.  The Thread::Exit exception
	  // is our sane C++ replacement of g_thread_exit().
	} catch(...) {
	  Glib::exception_handlers_invoke();
	}


    show_all_children();

}


MainWindow::~MainWindow() {

}