abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×

dnes 07:22 | Pozvánky

Konference InstallFest 2018 proběhne o víkendu 3. a 4. března 2018 v Praze na Karlově náměstí 13. Spuštěno bylo CFP. Přihlásit přednášku nebo workshop lze do 18. ledna 2018.

Ladislav Hagara | Komentářů: 0
včera 20:22 | Nová verze

Před měsícem byla vydána Fedora 27 ve dvou edicích: Workstation pro desktopové a Atomic pro cloudové nasazení. Fedora Server byl "vzhledem k náročnosti přechodu na modularitu" vydán pouze v betaverzi. Finální verze byla naplánována na leden 2018. Plán byl zrušen. Fedora 27 Server byl vydán již dnes. Jedná se ale o "klasický" server. Modularita se odkládá.

Ladislav Hagara | Komentářů: 0
včera 10:22 | Zajímavý článek

Lukáš Růžička v článku Kuchařka naší Růži aneb vaříme rychlou polévku z Beameru na MojeFedora.cz ukazuje "jak si rychle vytvořit prezentaci v LaTeXu, aniž bychom se přitom pouštěli do jeho bezedných hlubin".

Ladislav Hagara | Komentářů: 12
včera 07:22 | Komunita

Od 26. do 29. října proběhla v Bochumi European Coreboot Conference 2017 (ECC'17). Na programu této konference vývojářů a uživatelů corebootu, tj. svobodné náhrady proprietárních BIOSů, byla řada zajímavých přednášek. Jejich videozáznamy jsou postupně uvolňovány na YouTube.

Ladislav Hagara | Komentářů: 0
11.12. 19:22 | Nová verze

Ondřej Filip, výkonný ředitel sdružení CZ.NIC, oznámil vydání verze 2.0.0 open source routovacího démona BIRD (Wikipedie). Přehled novinek v diskusním listu a v aktualizované dokumentaci.

Ladislav Hagara | Komentářů: 0
11.12. 09:22 | Pozvánky

V Praze dnes probíhá Konference e-infrastruktury CESNET. Na programu je řada zajímavých přednášek. Sledovat je lze i online na stránce konference.

Ladislav Hagara | Komentářů: 2
9.12. 20:11 | Nová verze

Byl vydán Debian 9.3, tj. třetí opravná verze Debianu 9 s kódovým názvem Stretch a Debian 8.10, tj. desátá opravná verze Debianu 8 s kódovým názvem Jessie. Řešeny jsou především bezpečnostní problémy, ale také několik vážných chyb. Instalační média Debianu 9 a Debianu 8 lze samozřejmě nadále k instalaci používat. Po instalaci stačí systém aktualizovat.

Ladislav Hagara | Komentářů: 4
9.12. 00:44 | Nová verze

Po 6 měsících vývoje od vydání verze 0.13.0 byla vydána verze 0.14.0 správce balíčků GNU Guix a na něm postavené systémové distribuce GuixSD (Guix System Distribution). Na vývoji se podílelo 88 vývojářů. Přibylo 1 211 nových balíčků. Jejich aktuální počet je 6 668. Aktualizována byla také dokumentace.

Ladislav Hagara | Komentářů: 4
8.12. 21:33 | Nová verze

Po půl roce vývoje od vydání verze 5.9 byla vydána nová stabilní verze 5.10 toolkitu Qt. Přehled novinek na wiki stránce. Současně byla vydána nová verze 4.5.0 integrovaného vývojového prostředí (IDE) Qt Creator nebo verze 1.10 nástroje pro překlad a sestavení programů ze zdrojových kódů Qbs.

Ladislav Hagara | Komentářů: 0
7.12. 11:11 | Komunita

Naprostá většina příjmů Mozilly pochází od výchozích webových vyhledávačů ve Firefoxu. Do konce listopadu 2014 měla Mozilla globální smlouvu se společností Google. Následně bylo místo jedné globální smlouvy uzavřeno několik smluv s konkrétními vyhledávači pro jednotlivé země. V USA byla podepsána pětiletá smlouva s vyhledávačem Yahoo. Dle příspěvku na blogu Mozilly podala společnost Yahoo na Mozillu žalobu ohledně porušení této

… více »
Ladislav Hagara | Komentářů: 0
Jak se vás potenciálně dotkne trend odstraňování analogového audio konektoru typu 3,5mm jack z „chytrých telefonů“?
 (8%)
 (1%)
 (1%)
 (1%)
 (75%)
 (14%)
Celkem 965 hlasů
 Komentářů: 45, poslední 1.12. 19:00
    Rozcestník

    Grafické programy v Qt 4 – 11 (vláknování s QThreadPool)

    18. 8. 2010 | David Watzke | Programování | 5910×

    Hlavním tématem tohoto dílu je implementace vláknování s využitím objektů QThreadPoolQRunnable. Součástí článku je plnohodnotný program s grafickým uživatelským rozhraním využívající QThreadPool pro paralelizaci zadaných příkazů.

    K čemu je QThreadPool a QRunnable?

    QThreadPool je třída, která spravuje vlákna (QThread). Je součástí Qt od verze 4.4. Pokud váš program používá vlákna a často vytváří a ničí jejich instance, je vhodné použít QThreadPool, který umí efektivně znovupoužít objekty QThread. Jak se používá? Nejdříve si musíte vytvořit novou třídu založenou na QRunnable, což je obyčejná třída, která v základu ani není QObject (ale může být, chcete-li z ní třeba vysílat signály). Této třídě je třeba implementovat chráněnou (protected) metodu void run() tak, jak to znáte, pokud jste již používali QThread (viz článek Grafické programy v Qt 4 – 5 (regexpy, vlákna a ukazatel průběhu)). Zkrátka tato metoda obsahuje příkazy, které se budou provádět v jednom vlákně.

    class Runnable : public QRunnable
    {
    public:
    	Runnable() {}
    	~Runnable() {}
    
    protected:
    	void run()
    	{
    		qDebug() << "Pozdrav z vlákna" << QThread::currentThread();
    	}
    }
    

    Jakmile máte implementovanou třídu založenou na QRunnable, můžete začít spouštět vlákna. Každý Qt program má jednu globální instanci QThreadPool. Ukazatel na tuto instanci vám vrátí statická metoda QThreadPool::globalInstance(). Použití (z funkce) potom vypadá takto:

    Runnable *runnable = new Runnable();
    
    /* spustí se okamžitě, pokud není překročen počet běžících vláken
     * QThreadPool::maxThreadCount() a pokud je, zařadí se příkaz do fronty
     * a spustí se až nějaké vlákno skončí */
    
    QThreadPool::globalInstance()->start(runnable);
    
    Runnable *run2 = new Runnable();
    
    /* pokusí se spustit hned a když to vyjde, vrátí true
     * ale pokud to nejde, ihned vrátí false a nepřidá runnable do fronty */
    
    bool started = QThreadPool::globalInstance()->tryStart(run2);
    
    if(!started)
    	qDebug() << "run2 se nespustil";
    

    Jednu instanci Runnable lze spustit i víckrát než jednou. Ve výchozím režimu je povolené automatické ničení objektů Runnable ihned poté, co skončí vykonávání metody run(), takže jediná možnost je přímo z této metody zavolat QThreadPool::globalInstance->tryStart(this). Ovšem když automatické ničení objektů zakážete pomocí metody QRunnable::setAutoDelete(false) (a budete se o něj starat sami, jinak dojde k únikům paměti), tak se vás toto omezení netýká a můžete stejnou instanci pouštět znova a znova, jak se vám bude chtít.

    Ještě se sluší zmínit vychytávky jako podpora priorit a rezervování vláken. Spouštíte-li runnable přes QThreadPool::start(), můžete uvést i prioritu (integer), podle které se příkaz zařadí do fronty dolů nebo nahoru. Větší číslo symbolizuje větší prioritu.

    QThreadPool->globalInstance->start(runnable, 10);
    

    Rezervování vlákna se hodí, pokud nutně potřebujete vlákno pro zvláštní účely a nezáleží vám na tom, že se může dočasně přesáhnout předem nastavený maximální počet vláken. Toto se provádí metodou QThreadPool::reserveThread() a je to také důvod, proč QThreadPool::activeThreadCount() (počet aktivních vláken) může převýšit hodnotu QThreadPool::maxThreadCount() (maximální počet vláken). Poté co s rezervovaným vláknem skončíte, zavolejte QThreadPool::releaseThread(), aby mohlo být vlákno dále běžně používáno.

    Program QtJobs

    Program QtJobs jsem začal psát proto, abych si vyzkoušel práci s threadpool a zároveň aby rovnou vzniklo něco trochu užitečného. Na ukázkový program je sice docela velký, ale aspoň je na něm vidět použití spousty věcí, které jsem zmiňoval v minulých dílech (hlavní okno programu, nastavení, Qt Designer, regulární výrazy, vlákna a ukazatel průběhu, externí procesy, taby, modální oknalokalizace). Uživatelské rozhraní vypadá takto:

    qt qt qt

    Program slouží k paralelnímu spouštění příkazů v tolika vláknech, kolik je ideální pro váš systém (případně si můžete zvolit vlastní počet vláken). Znáte-li program xjobs, tak můj program by se dal považovat za něco podobného s GUI. Představte si, že chcete dekódovat MP3 (do WAV) pomocí lame --decode, které pracuje v jednom vlákně. Zkusil jsem takto dekódovat jedno album a trvalo to na mém dvoujádrovém CPU s HT skoro 38 sekund. Když jsem použil QtJobs, který dle počtu logických procesorů zvolil 4 vlákna, stejného výsledku jsem docílil za 20 sekund.

    Použití je vcelku jednoduché. Na prvním tabu je seznam souborů, do kterého přidáte vstupní soubory (v našem případě by to byly MP3 soubory). Na dalším tabu nastavíte příkaz, který se na soubory bude pouštět a název výstupních souborů (změnu přípony, výstupní adresář, atp.). Do příkazu nezapomeňte uvést proměnnou $FILE, která bude nahrazena za název vstupního souboru, a proměnnou $OFILE, která bude nahrazena za název výstupního souboru. Použití proměnné $OFILE je volitelné, ale má-li se projevit nastavení výstupního souboru, je třeba ji uvést. Příkaz pro dekódování MP3 by tedy vypadal takto:

    lame --decode $FILE $OFILE
    

    Program podporuje profily, takže nemusíte stále dokola vyplňovat to samé, stačí to udělat jednou a profil uložit například s názvem „Dekódování MP3“ a příště jej jen načíst. Když máte vše nastavené, stisknete tlačítko „Spustit“, čímž to celé odstartujete. Program vás přepne na třetí tab, kde je ukazatel průběhu, možnost příkazy zastavit či zabít, a také seznam běžících příkazů, seznam úspěšně zpracovaných souborů a seznam příkazů, které skončily s nenulovou návratovou hodnotou.

    A následuje okomentovaný kód, který uvolňuji pod GPLv3. Celý projekt si můžete stáhnout přes Git pomocí příkazu:

    git clone git://repo.or.cz/qtjobs.git
    

    Zkompilujete jej jako vždy spuštěním příkazu qmake && make v adresáři s kódem. Lokalizaci sestavíte příkazem: lrelease qtjobs.pro. Aktuální i starší verze zdrojáků si můžete prohlédnout přes gitweb.

    main.cpp: Nic nového: Nastavíme název programu a doménu (či organizaci) pro QSettings, načteme případnou lokalizaci, zobrazíme hlavní okno a spustíme smyčku událostí.

    #include <QtGui/QApplication>
    #include <QtCore/QTextCodec>
    #include <QtCore/QLocale>
    #include <QtCore/QTranslator>
    #include "mainwindow.h"
    
    int main(int argc, char *argv[])
    {
    	QApplication app(argc, argv);
    
    	// údaje pro QSettings (konfigurák)
    	app.setApplicationName("qtjobs");
    	app.setOrganizationDomain("watzke.cz");
    
    	// nastavíme kódování pro lokalizaci a řetězce C
    	{
    	QTextCodec *utf8 = QTextCodec::codecForName("UTF-8");
    	QTextCodec::setCodecForCStrings(utf8);
    	QTextCodec::setCodecForTr(utf8);
    	}
    
    	// načteme lokalizaci
    	QTranslator tr;
    	tr.load(app.applicationName() + "_" + QLocale::system().name());
    	app.installTranslator(&tr);
    
    	// zobrazíme hlavní okno
    	MainWindow wnd;
    	wnd.show();
    
    	// spustíme smyčku událostí
    	return app.exec();
    }
    

    mainwindow.h: API.

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QList>
    #include <QMainWindow>
    #include <QSettings>
    #include <QDebug>
    
    #include "runnable.h"
    
    namespace Ui
    {
    	class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
    	Q_OBJECT
    public:
    	MainWindow(QWidget *parent = 0);
    	~MainWindow();
    
    //	friend class Runnable;
    
    protected:
    	void changeEvent(QEvent *e);
    
    private:
    	Ui::MainWindow *ui;
    	QSettings m_profiles;
    	QList<Runnable*> m_runnables;
    	bool m_ok;
    
    	void loadProfiles(bool load_default = true);
    	void checkProcessing();
    
    private slots:
    	void addFiles();
    	void forceExtensionChange(bool force);
    	void removeSelectedFiles();
    
    	void removeSelectedProfile();
    	void loadSelectedProfile();
    	void saveProfile();
    
    	void runJobs();
    	void stopJobs();
    	void killJobs();
    
    	void setGuiProcessingState(bool processing);
    
    	void removeRunnable(Runnable* runnable, bool ok = true);
    
    	void startedJob(QString cmd);
    	void doneJob(QString cmd, QString file, int retcode);
    	void failedJob(QString error);
    };
    
    #endif // MAINWINDOW_H
    

    mainwindow.cpp: Implementace hlavního okna. Hlavní okno v případě tohoto programu dělá vše kromě samotného spouštění příkazů, které probíhá ve vláknech voláním Runnable::run(). Uživatelské rozhraní je navržené v Qt Designeru, čímž odpadá velká část nudného rutinního kódu.

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    #include <QtGui>
    #include <QThreadPool>
    
    MainWindow::MainWindow(QWidget *parent) :
    	QMainWindow(parent),
    	ui(new Ui::MainWindow), m_ok(true)
    {
    	// načte navržené GUI
    	ui->setupUi(this);
    
    	// aktivuje první tab
    	ui->tabWidget->setCurrentIndex(0);
    
    	// nastaví počet ideální vláken do spinboxu
    	ui->threadBox->setValue(QThread::idealThreadCount());
    
    	/* za jak dlouho se vlákno zničí při nečinnosti…
    		výchozích 30 s je moc, protože pak se může stát, že
    		program nebude respektovat nastavení počtu vláken */
    	QThreadPool::globalInstance()->setExpiryTimeout(100);
    
    	// načte profily
    	loadProfiles();
    }
    
    /* nechá uživatele vybrat soubory přes souborový dialog a
    	přidá je do seznamu */
    void MainWindow::addFiles()
    {
    	QStringList files = QFileDialog::getOpenFileNames(this,
    				tr("Select files to be processed"),
    				QDir::homePath());
    	ui->fileList->addItems(files);
    }
    
    /* odstraní vybrané soubory ze seznamu */
    void MainWindow::removeSelectedFiles()
    {
    	QList<QListWidgetItem*> items = ui->fileList->selectedItems();
    
    	ui->fileList->setUpdatesEnabled(false);
    
    	while(!items.isEmpty())
    		delete items.takeLast();
    
    	ui->fileList->setUpdatesEnabled(true);
    }
    
    /* načte profily a případně vytvoří výchozí (prázdný) profil */
    void MainWindow::loadProfiles(bool load_default)
    {
    	// ujistíme se, že je comboBox prázdný (důležité pro znovunačtení)
    	while(ui->comboProfile->count())
    		ui->comboProfile->removeItem(0);
    
    	QStringList profiles = m_profiles.childGroups();
    
    	// vytvoříme výchozí (prázdný) profil, pokud žádný neexistuje
    	if(!profiles.contains("default"))
    	{
    		m_profiles.beginGroup("default");
    		m_profiles.setValue("name", tr("Default"));
    		m_profiles.setValue("command", QString());
    		m_profiles.setValue("extension", QString("ext"));
    		m_profiles.setValue("outdir", QDir::homePath());
    		m_profiles.setValue("samedir", false);
    		m_profiles.setValue("want_extension", false);
    		m_profiles.setValue("autothread", true);
    		m_profiles.setValue("threadcount", QThread::idealThreadCount());
    		m_profiles.endGroup();
    
    		profiles << "default";
    	}
    
    	// přidáme dostupné profily do comboBoxu
    	foreach(QString profile, profiles)
    	{
    		m_profiles.beginGroup(profile);
    		QString name = m_profiles.value("name").toString();
    		m_profiles.endGroup();
    
    		if(name.isEmpty())
    			continue;
    
    		//qDebug() << "adding profile" << profile << "as" << name;
    
    		ui->comboProfile->addItem(name, profile);
    	}
    
    	if(load_default)
    	{
    		// nalistujeme v comboBoxu výchozí profil
    		int index = ui->comboProfile->findData("default");
    		ui->comboProfile->setCurrentIndex(index);
    
    		// načteme jej
    		loadSelectedProfile();
    	}
    }
    
    /* odstraní vybraný profil */
    void MainWindow::removeSelectedProfile()
    {
    	// zjistíme index vybraného profilu
    	int index = ui->comboProfile->currentIndex();
    	// a jeho název
    	QString profile = ui->comboProfile->itemData(index).toString();
    
    	if(profile.isEmpty())
    		return;
    
    	// nedovolíme smazat výchozí profil
    	if(profile == "default")
    	{
    		QMessageBox::critical(this, tr("Error!"),
    				      tr("You cannot remove the default profile!"));
    		return;
    	}
    
    	// odstraníme z comboBoxu
    	ui->comboProfile->removeItem(index);
    
    	// nalistujeme výchozí profil
    	index = ui->comboProfile->findData("default");
    	ui->comboProfile->setCurrentIndex(index);
    
    	// odstraníme z konfiguráku
    	m_profiles.remove(profile);
    }
    
    /* načte vybraný profil */
    void MainWindow::loadSelectedProfile()
    {
    	// zjistíme index vybraného profilu
    	int index = ui->comboProfile->currentIndex();
    	// a jeho název
    	QString profile = ui->comboProfile->itemData(index).toString();
    
    	// touhle dobou už bychom měli znát název profilu (pro načtení)
    	Q_ASSERT(!profile.isEmpty());
    
    	// načteme proměnné z nastavení
    	m_profiles.beginGroup(profile);
    	QString command = m_profiles.value("command").toString();
    	QString extension = m_profiles.value("extension", "ext").toString();
    	QString outdir = m_profiles.value("outdir", QDir::homePath()).toString();
    	bool samedir = m_profiles.value("samedir", false).toBool();
    	bool want_extension = m_profiles.value("want_extension", false).toBool();
    	bool autothread = m_profiles.value("autothread", true).toBool();
    	int threadcount = m_profiles.value("threadcount", QThread::idealThreadCount()).toInt();
    	m_profiles.endGroup();
    
    	// nastavíme načtené nastavení:
    	// 1) příkaz
    	ui->commandEdit->setText(command);
    
    	// 2) příponu
    	if(!want_extension)
    		ui->extCb->setChecked(false);
    	else
    	{
    		ui->extCb->setChecked(true);
    		ui->extEdit->setText(extension);
    	}
    
    	// 3) výstupní adresář
    	if(samedir)
    		ui->radioSame->setChecked(true);
    	else
    	{
    		ui->radioOther->setChecked(true);
    		ui->outDirEdit->setText(outdir);
    	}
    
    	// 4) nastavení vláken
    	ui->threadcountCb->setChecked(!autothread);
    	ui->threadBox->setValue(threadcount);
    }
    
    /* uloží profil */
    void MainWindow::saveProfile()
    {
    	// název profilu načteme z patřičného textového pole
    	QString profile = ui->profileEdit->text();
    
    	// pokud název nebyl zadán, přepíšeme aktuálně nalistovaný profil
    	if(profile.isEmpty())
    	{
    		int index = ui->comboProfile->currentIndex();
    		profile = ui->comboProfile->itemData(index).toString();
    	}
    
    	// touhle dobou už bychom rozhodně měli znát název profilu (pro uložení)
    	Q_ASSERT(!profile.isEmpty());
    
    	// uložíme požadované hodnoty
    	m_profiles.beginGroup(profile);
    	m_profiles.setValue("name", profile);
    	m_profiles.setValue("command", ui->commandEdit->text());
    	m_profiles.setValue("extension", ui->extEdit->text());
    	m_profiles.setValue("outdir", ui->outDirEdit->text());
    	m_profiles.setValue("samedir", ui->radioSame->isChecked());
    	m_profiles.setValue("want_extension", ui->extCb->isChecked());
    	m_profiles.setValue("autothread", !ui->threadcountCb->isChecked());
    	m_profiles.setValue("threadcount", ui->threadBox->value());
    	m_profiles.endGroup();
    
    	// znovu načíst seznam profilů
    	loadProfiles(false);
    
    	// vybrat nově uložený profil
    	int index = ui->comboProfile->findData(profile);
    	ui->comboProfile->setCurrentIndex(index);
    
    	// načíst nově uložený profil
    	loadSelectedProfile();
    
    	// vyprázdnit pole s názvem pro nový profil
    	ui->profileEdit->setText("");
    }
    
    /* spustí příkazy */
    void MainWindow::runJobs()
    {
    	// obnovit stav widgetů z minulého běhu
    	ui->commandList->clear();
    	ui->processedList->clear();
    	ui->errorList->clear();
    	ui->progressBar->reset();
    
    	// vytvoříme seznam názvů souborů
    	QStringList fileList;
    	int count = ui->fileList->count();
    
    	for(int i=0; i < count; ++i)
    		fileList << ui->fileList->item(i)->text();
    
    	// kontrola, zda byly zadány nějaké soubory
    	if(count < 1)
    	{
    		QMessageBox::critical(this, tr("Error!"),
    			tr("Please add some files to the file list on the \"File "
    			   "list\" tab."));
    		return;
    	}
    
    	// je zadána přípona?
    	if(ui->extCb->isChecked() && ui->extEdit->text().isEmpty())
    	{
    		QMessageBox::critical(this, tr("Error!"),
    			tr("Please either enter an extension or uncheck the option "
    			   "for it's changing."));
    		return;
    	}
    
    	// byl zadán platný výstupní adresář?
    	if(ui->radioOther->isChecked())
    	{
    		QFileInfo dirInfo(ui->outDirEdit->text());
    		if(!dirInfo.isDir() || !dirInfo.isWritable())
    		{
    			QMessageBox::critical(this, tr("Error!"),
    				tr("Please select a valid writable output directory."));
    			return;
    		}
    	}
    
    	// obsahuje příkaz proměnnou $FILE?
    	if(!ui->commandEdit->text().contains("$FILE"))
    	{
    		QMessageBox::critical(this, tr("Error!"),
    			tr("The command must contain the $FILE variable (and should "
    			   "also contain the optional $OFILE variable)."));
    		return;
    	}
    
    	// nastavíme ukazatel průběhu
    	ui->progressBar->setRange(0, count);
    	ui->progressBar->setFormat("%v/%m (%p%)");
    	ui->progressBar->setValue(0);
    
    	// nastavíme počet vláken
    	int threadcount = QThread::idealThreadCount();
    
    	if(ui->threadcountCb->isChecked())
    		threadcount = ui->threadBox->value();
    
    	QThreadPool::globalInstance()->setMaxThreadCount(threadcount);
    
    	// přepneme GUI do stavu zpracovávání
    	setGuiProcessingState(true);
    
    	// přidáme všechny příkazy do fronty…
    	foreach(QString fileName, fileList)
    	{
    		// naše struktura s nastavením
    		RunnableSettings s;
    
    		// příkaz
    		s.command = ui->commandEdit->text();
    		// přípona
    		s.extension = ui->extEdit->text();
    		// výstupní adresář
    		s.outdir = ui->outDirEdit->text();
    		// vstupní soubor
    		s.infile = fileName;
    		// chceme příponu?
    		s.bExtension = ui->extCb->isChecked();
    		// chceme ukládat do adresáře, kde je uložen vstupní soubor?
    		s.bSameDir = ui->radioSame->isChecked();
    
    		Runnable *runnable = new Runnable(s);
    		// propojíme signály
    		connect(runnable, SIGNAL(destroyMe(Runnable*,bool)),
    			this, SLOT(removeRunnable(Runnable*,bool)));
    		connect(runnable, SIGNAL(started(QString)),
    			this, SLOT(startedJob(QString)));
    		connect(runnable, SIGNAL(done(QString,QString,int)),
    			this, SLOT(doneJob(QString,QString,int)));
    		connect(runnable, SIGNAL(failed(QString)),
    			this, SLOT(failedJob(QString)));
    
    		// přidáme objekt do seznamu
    		m_runnables << runnable;
    
    		// a přidáme job do threadpoolu
    		QThreadPool::globalInstance()->start(runnable);
    	}
    
    	// přepnout na tab s průběhem
    	ui->tabWidget->setCurrentIndex(2);
    }
    
    /* zastaví příkazy */
    void MainWindow::stopJobs()
    {
    	foreach(Runnable *runnable, m_runnables)
    		runnable->stop();
    }
    
    /* zabije příkazy */
    void MainWindow::killJobs()
    {
    	foreach(Runnable *runnable, m_runnables)
    		runnable->kill();
    }
    
    /* odstraní dokončený příkaz (instanci Runnable) */
    void MainWindow::removeRunnable(Runnable *runnable, bool ok)
    {
    	m_runnables.removeAll(runnable);
    	delete runnable;
    
    	if(!ok)
    		m_ok = false;
    
    	checkProcessing();
    }
    
    /* slot pro „příkaz byl spuštěn“ */
    void MainWindow::startedJob(QString cmd)
    {
    	// přidá příkaz do seznamu příkazů
    	new QListWidgetItem(cmd, ui->commandList);
    }
    
    /* slot pro „příkaz byl dokončen“ (s názvem souboru a návratovou hodnotou) */
    void MainWindow::doneJob(QString cmd, QString file, int retcode)
    {
    	// aktualizujeme hodnotu v ukazateli průběhu
    	int done = ui->progressBar->value()+1;
    	ui->progressBar->setValue(done);
    
    	/* podle návratové hodnoty přidáme soubor do seznamu úspěšně zpracovaných
    	   nebo přidáme příkaz do seznamu chyb */
    	if(!retcode)
    		ui->processedList->addItem(file);
    	else
    	{
    		QString error = QString(tr("command returned %1: %2")).arg(retcode).arg(cmd);
    		ui->errorList->addItem(error);
    	}
    
    	// najdeme v seznamu běžících příkazů ten, který právě skončil
    	QList<QListWidgetItem*> item = ui->commandList->findItems(cmd,
    						Qt::MatchExactly|Qt::MatchCaseSensitive);
    
    	//Q_ASSERT(item.count() == 1);
    
    	// ověříme, zda jsme nalezli jen 1
    	if(item.count() != 1)
    	{
    		qDebug() << "WARNING: removeCommandFromList() found >1 item."
    			 << "This shouldn't happen. Items:";
    		foreach(QListWidgetItem* it, item)
    			qDebug() << "> " << it->text();
    	}
    
    	// a smažeme jej
    	if(item.count() > 0)
    		delete item.at(0);
    	else
    		qDebug() << "BUG: removeCommandFromList() found no items."
    			 << "This should never happen.";
    }
    
    /* slot pro „příkaz selhal“ */
    void MainWindow::failedJob(QString error)
    {
    	// aktualizujeme hodnotu v ukazateli průběhu
    	int done = ui->progressBar->value()+1;
    	ui->progressBar->setValue(done);
    
    	// přidáme do seznamu chyb
    	ui->errorList->addItem(error);
    }
    
    /* přepne GUI do stavu zpracovávání (nebo naopak) */
    void MainWindow::setGuiProcessingState(bool processing)
    {
    	ui->runBtn->setDisabled(processing);
    	ui->stopBtn->setEnabled(processing);
    	ui->killBtn->setEnabled(processing);
    
    	if(processing)
    		m_ok = true;
    }
    
    /* zkontroluje, zda už je vše hotovo a ukáže patřičnou zprávu */
    void MainWindow::checkProcessing()
    {
    	// pokud v seznamu jsou ještě úlohy, tak hned vrátíme
    	if(m_runnables.count())
    		return;
    
    	// zdá se, že máme hotovo
    
    	if(QThreadPool::globalInstance()->activeThreadCount() != 0)
    		qDebug() << "looks like processing is done but"
    			 << "QThreadPool::activeThreadCount() != 0";
    
    	// vrátíme GUI do klidového stavu
    	setGuiProcessingState(false);
    
    	// vyprázdníme seznam příkazů (pro jistotu)
    	ui->commandList->clear();
    	//ui->processedList->clear();
    
    	// hotovo bez chyb
    	if(m_ok && !ui->errorList->count())
    		QMessageBox::information(this, tr("Done!"),
    			tr("Done! All the files were successfully processed!"));
    	else if(m_ok)
    	{ // hotovo s chybami
    		QMessageBox::StandardButton btn;
    		btn = QMessageBox::warning(this, tr("Done with errors!"),
    				tr("Done with errors! See the list of the failed "
    				   "commands on the \"Progress\" tab."));
    		if(btn == QMessageBox::Ok)
    			ui->tabWidget->setCurrentIndex(2);
    	} // přerušeno uživatelem
    	else
    		QMessageBox::critical(this, tr("Interrupted!"),
    			tr("Processing was interrupted by pressing the Stop or "
    			   "the KILL button."));
    
    	// resetujeme ukazatel průběhu
    	ui->progressBar->reset();
    }
    
    /* vynutí změnu přípony
    	-> hodí se (nejen), když výstupní soubory ukládáte do stejného adresáře */
    void MainWindow::forceExtensionChange(bool force)
    {
    	// pokud změnu přípony chceme vynutit, tak zaškrtneme příslušné pole
    	if(force)
    		ui->extCb->setChecked(true);
    
    	// povolí nebo zakáže změnu zaškrtávacího pole
    	ui->extCb->setDisabled(force);
    }
    
    /* výchozí destruktor */
    MainWindow::~MainWindow()
    {
    	delete ui;
    }
    
    /* tuhle funkci vygeneroval Qt Creator sám;
     umožňuje měnit lokalizaci za běhu… */
    void MainWindow::changeEvent(QEvent *e)
    {
    	QMainWindow::changeEvent(e);
    
    	switch(e->type())
    	{
    	case QEvent::LanguageChange:
    		ui->retranslateUi(this);
    		break;
    	default:
    		break;
    	}
    }
    

    runnable.h: API. Zde je jedna malá zvláštnost: Objekt zakládáme nejen na QRunnable, ale i na QObject, protože potřebujeme vysílat signály hlavnímu oknu. Zasahovat do uživatelského rozhraní z jiného vlákna, než je to hlavní (tzv. GUI vlákno), není příliš moudré: V lepších případech se projeví varováním na výstupu, ovšem častěji spíše pádem programu. To je důvod, proč komunikujeme pomocí signálů.

    #ifndef RUNNABLE_H
    #define RUNNABLE_H
    
    #include <QObject>
    #include <QRunnable>
    #include <QString>
    
    // struktura s informacemi pro Runnable
    struct RunnableSettings
    {
    	QString command;
    	QString extension;
    	QString outdir;
    	QString infile;
    	//QString outfile;
    	bool bExtension;
    	bool bSameDir;
    };
    
    // chceme ze třídy vysílat signály, proto ji zakládáme i na QObjectu
    class Runnable : public QObject, public QRunnable
    {
    	// nezapomeneme na makro Q_OBJECT
    	Q_OBJECT
    public:
    	Runnable(const RunnableSettings &s);
    
    	void stop() { m_stop = true; }
    	void kill() { stop(); m_kill = true; }
    
    protected:
    	void run();
    
    private:
    	QString m_command;
    	QString m_infile;
    
    	bool m_stop;
    	bool m_kill;
    
    signals:
    	void started(QString);
    	void done(QString,QString,int);
    	void failed(QString);
    	void destroyMe(Runnable*,bool);
    };
    
    #endif // RUNNABLE_H
    

    runnable.cpp: Implementace.

    #include "runnable.h"
    
    #include <QDebug>
    #include <QDir>
    #include <QFileInfo>
    #include <QProcess>
    #include <QRegExp>
    
    Runnable::Runnable(const RunnableSettings &s)
    	: m_stop(false), m_kill(false)
    {
    	/* zakážeme automatické ničení objektů Runnable, protože se o
    		jejich správu staráme sami */
    	setAutoDelete(false);
    
    	// uložíme příkaz a název vstupního souboru do členské proměnné
    	m_infile = s.infile;
    	m_command = s.command;
    
    	// sestavíme cestu k výstupnímu souboru…
    	QFileInfo fileInfo(m_infile);
    	QString outfile;
    
    	// adresář (stejný nebo zadaný?)
    	if(s.bSameDir)
    		outfile = fileInfo.dir().canonicalPath() + "/";
    	else
    		outfile = s.outdir + "/";
    
    	// soubor
    	QString fileName = fileInfo.fileName();
    
    	// změna přípony
    	if(s.bExtension)
    	{
    		QRegExp regex("^(.*)\\.(\\w+)$", Qt::CaseInsensitive,
    						 QRegExp::RegExp2);
    		fileName.replace(regex, "\\1." + s.extension);
    	}
    
    	outfile += fileName;
    
    	// nahradíme proměnné $FILE a $OFILE
    	m_command.replace("$FILE", "\""+m_infile+"\"");
    	m_command.replace("$OFILE", "\""+outfile+"\"");
    }
    
    void Runnable::run()
    {
    	// pokud uživatel stiskl „Zastavit“ či „ZABÍT“, tak ani nezačínáme
    	if(m_stop)
    	{
    		//qDebug() << "user pressed Stop or KILL, so not even starting";
    		emit destroyMe(this, false);
    		return;
    	}
    
    	//qDebug() << this << "running" << m_command;
    
    	QProcess process;
    
    	// spustíme příkaz
    	process.start(m_command, QIODevice::ReadWrite|QIODevice::Text);
    
    	// počkáme, až se spustí
    	if(process.waitForStarted(1000))
    	{
    		// vyšleme signál, že příkaz byl spuštěn
    		emit started(m_command);
    	}
    	else
    	{ // pokud spouštění příkazu selhalo
    		// chybová hláška
    		QString errorString = tr("command failed to start");
    
    		if(process.error() != QProcess::FailedToStart)
    			errorString = tr("command failed due to an unknown error");
    
    		// vyšleme signál, že příkaz selhal
    		emit failed(errorString + ": " + m_command);
    
    		/*process.kill();
    		// počkáme na zabití procesu, maximálně 1 s
    		process.waitForFinished(1000);*/
    
    		emit destroyMe(this, true);
    
    		return;
    	}
    
    	// smyčka kontrolující, zda uživatel stiskl „ZABÍT“
    	while(m_kill || !process.waitForFinished(200))
    	{
    		// pokud ne, dále čekáme na dokončení procesu
    		if(!m_kill)
    			continue;
    
    		qDebug() << "killing" << m_command;
    
    		// zabijeme proces
    		process.kill();
    
    		break;
    	}
    
    	// počkáme na zabití procesu, maximálně 1 s
    	process.waitForFinished(1000);
    
    	// příkaz doběhl
    	emit done(m_command, m_infile, m_kill ? 137 : process.exitCode());
    	// vyžadáme zničení objektu
    	emit destroyMe(this, !m_kill);
    }
    

    Není-li vám něco jasné, určitě se zeptejte v diskusi. Zrovna tak tam napište, když v programu najdete chybu; hodně jsem jich opravil při testování, ale jsem jen člověk, mohl jsem něco přehlédnout.

           

    Hodnocení: 100 %

            špatnédobré        

    Nástroje: Tisk bez diskuse

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    Komentáře

    Vložit další komentář

    18.8.2010 11:32 JoHnY2
    Rozbalit Rozbalit vše Re: Grafické programy v Qt 4 – 11 (vláknování s QThreadPool)
    Dik za dalsi clanek o Qt. Diky tem predchozim jsem udelal semestralku z C++ka :-).
    18.8.2010 21:44 Xwinus
    Rozbalit Rozbalit vše Re: Grafické programy v Qt 4 – 11 (vláknování s QThreadPool)
    Díky za super sérii článků, která mě přivedla ke Qt. Doufám že tento není poslední.
    oryctolagus avatar 20.8.2010 23:57 oryctolagus | skóre: 29 | blog: Untitled
    Rozbalit Rozbalit vše Re: Grafické programy v Qt 4 – 11 (vláknování s QThreadPool)
    Pěknej článek. Líbí se mi terminus technicus "vláknování" ;-)

    (Teda on by ten prográmek šel řešit celkem dobře i bez ThreadPoolu, no ale samozřejmě chápu, že na tom by se špatně vysvětloval ThreadPool ;-))
    There are two hard things in computer science: cache invalidation, naming things, and off-by-one errors.
    27.8.2010 11:55 smoegel
    Rozbalit Rozbalit vše Re: Grafické programy v Qt 4 – 11 (vláknování s QThreadPool)
    Velmi uzitocne :-) Dakujem za namahu a ochotu vysvetlovat pre niekoho mozno trivialne veci. Pre prilezitostneho programatora ako som ja je to 100x nazornejsie ako dokumentacia QT.

    este raz dik

    Založit nové vláknoNahoru

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.