Ana Sayfa Algoritma ve Programlama Qt C++ Kütüphanesi ile GAP - Sinyal ve Slot

Qt C++ Kütüphanesi ile GAP – Sinyal ve Slot

3. derste kaldığımız yerden devam edelim en son görünümleri ve görünümlerin içerisine bileşenleri eklemiştik. Bileşenleri ekledikten sonra Qt Designer’da sağ tarafta bulunan Özellikler (Properties) bölümünde bileşenlerin özelliklerini tek tek belirleyeceğiz. Metin tarayıcıyı seçtikten sonra sağ tarafta bu bileşenin özellikleri gösterilmektedir. Nesne adı (objectName) özelliğini kullanarak bileşenin kodda hangi değişkenle temsil edileceğini belirleyebiliriz. Biz burada metin tarayıcısı için bufferBrowser değişkenini kullanacağız.

İlerleme çubuğunun önüne yerleştirdiğimiz etiket için progressbarLabel değiken ismini kullanacağız. Burada tek tek değişken isimlerini saymaya gerek görmüyorum. Kodu incelediğinizde zaten bütün bileşenlerin hangi isimlerle çağrılacağını görmüş olacaksınız. Aşağıda program için oluşturduğumuz arayüzün son hali gözüküyor.

Sinyal ve Slot

Şimdi yine Qt Designer kullanarak uygulamamıza Sinyal ve Slot fonksiyonlarını tanıtacağız. Hatırlayacağınız üzere uygulamamızda iki buton olacaktı. Birincisi “Yaz”, diğeri “Oku” butonları. “Yaz” butonuna basıldığında uygulamamız kendisi için ayrılan belleğe rasgele seçerek A, C, G, T harflerinden birisini yazar. “Oku” butonuna basıldığında ise belleğe yazılan harfler okunarak ekranda metin tarayıcı bileşeninde gösterilir. Aşağıda tıklama (clicked) sinyalinin “Yaz” butonuna eklenmesi ve bu sinyale cevap olarak ana pencere sınıfına – bu uyguglama için SignalSlotExampleClass – on_writeButton_clicked slotunun eklenmesi gösterilmiştir. İşlemler sırasıyla şu şekildedir:

  1. Sinyal/Slot düzenleme moduna geçilmesi
  2. İlgili butonun seçilir. Bu sırada Qt Designer bu bileşenden yayılan sinyalin hangi bileşen tarafından karşılanacağını belirlemeniz için yol gösterir. Siz de istediğiniz bileşeni seçersiniz.
  3. İlk seçtiğiniz sinyal yayıcı bileşenden hangi sinyalin yayınlanacağı seçilir.
  4. Sinyale cevap verecek slot belirlenir.
  5. Qt Designer’da hazır bulunan slotlardan farklı bir slot kullanacağımız için yeni slotu + sembolüne basarak ekliyoruz.
  6. Yeni eklenen slotu göstermektedir.

Qt Designer Sinyal ve Slot

Qt Designer ile bu slotun eklenmesi aslında sadece uygulamaya yapılmış bir bildirimdir. Slotun ne yapacağını henüz tanımlamadık. Qt Designer ile bu sinyal/slotun belirlenmesi koda aşağıdaki satırın eklenmesine sebep olur:

QObject::connect(writeButton, SIGNAL(clicked()), SignalSlotExampleClass, SLOT(on_writeButton_clicked()));

connect fonksiyonu programda hangi bileşenin hangi sinyali yayacağını ve cevap olarak hangi fonksiyonun çağrılacağını belirler.

Ardından readButton için benzer şekilde sinyal/slot ekleyeceğiz. Bu işlem de çok benzer olduğu için ayrıca göstermiyorum. Bu arayüzü kaydedip VS19 ile derlediğimizde aşağıdaki kodu bizim için otomatik olarak oluşturur. Standart bir uygulamada menü çubuğu (menu bar) ve araç çubuğu (tool bar) olduğu için VS19 ile standart bir Qt uygulaması açtığınızda bu iki bileşen otomatik olarak gelmektedir. Bunlara şimdilik takılmayın.


/********************************************************************************
** Form generated from reading UI file 'SignalSlotExample.ui'
**
** Created by: Qt User Interface Compiler version 5.9.9
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_SIGNALSLOTEXAMPLE_H
#define UI_SIGNALSLOTEXAMPLE_H
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QProgressBar>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QTextBrowser>
#include <QtWidgets/QToolBar>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_SignalSlotExampleClass
{
public:
QWidget *centralWidget;
QGridLayout *gridLayout;
QVBoxLayout *verticalLayout;
QVBoxLayout *verticalLayout_2;
QTextBrowser *bufferBrowser;
QHBoxLayout *horizontalLayout_2;
QLabel *progressbarLabel;
QProgressBar *numOfCharBar;
QHBoxLayout *horizontalLayout;
QSpacerItem *horizontalSpacer_2;
QPushButton *readButton;
QSpacerItem *horizontalSpacer;
QPushButton *writeButton;
QSpacerItem *horizontalSpacer_3;
QMenuBar *menuBar;
QToolBar *mainToolBar;
QStatusBar *statusBar;
void setupUi(QMainWindow *SignalSlotExampleClass)
{
if (SignalSlotExampleClass->objectName().isEmpty())
SignalSlotExampleClass->setObjectName(QStringLiteral("SignalSlotExampleClass"));
SignalSlotExampleClass->resize(600, 400);
centralWidget = new QWidget(SignalSlotExampleClass);
centralWidget->setObjectName(QStringLiteral("centralWidget"));
gridLayout = new QGridLayout(centralWidget);
gridLayout->setSpacing(6);
gridLayout->setContentsMargins(11, 11, 11, 11);
gridLayout->setObjectName(QStringLiteral("gridLayout"));
verticalLayout = new QVBoxLayout();
verticalLayout->setSpacing(6);
verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
verticalLayout_2 = new QVBoxLayout();
verticalLayout_2->setSpacing(6);
verticalLayout_2->setObjectName(QStringLiteral("verticalLayout_2"));
bufferBrowser = new QTextBrowser(centralWidget);
bufferBrowser->setObjectName(QStringLiteral("bufferBrowser"));
bufferBrowser->setReadOnly(true);
verticalLayout_2->addWidget(bufferBrowser);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setSpacing(6);
horizontalLayout_2->setObjectName(QStringLiteral("horizontalLayout_2"));
progressbarLabel = new QLabel(centralWidget);
progressbarLabel->setObjectName(QStringLiteral("progressbarLabel"));
horizontalLayout_2->addWidget(progressbarLabel);
numOfCharBar = new QProgressBar(centralWidget);
numOfCharBar->setObjectName(QStringLiteral("numOfCharBar"));
numOfCharBar->setMaximum(256);
numOfCharBar->setValue(0);
horizontalLayout_2->addWidget(numOfCharBar);
verticalLayout_2->addLayout(horizontalLayout_2);
verticalLayout->addLayout(verticalLayout_2);
horizontalLayout = new QHBoxLayout();
horizontalLayout->setSpacing(6);
horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
horizontalLayout->setSizeConstraint(QLayout::SetDefaultConstraint);
horizontalSpacer_2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout->addItem(horizontalSpacer_2);
readButton = new QPushButton(centralWidget);
readButton->setObjectName(QStringLiteral("readButton"));
QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(readButton->sizePolicy().hasHeightForWidth());
readButton->setSizePolicy(sizePolicy);
horizontalLayout->addWidget(readButton);
horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout->addItem(horizontalSpacer);
writeButton = new QPushButton(centralWidget);
writeButton->setObjectName(QStringLiteral("writeButton"));
sizePolicy.setHeightForWidth(writeButton->sizePolicy().hasHeightForWidth());
writeButton->setSizePolicy(sizePolicy);
horizontalLayout->addWidget(writeButton);
horizontalSpacer_3 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
horizontalLayout->addItem(horizontalSpacer_3);
horizontalLayout->setStretch(0, 1);
horizontalLayout->setStretch(1, 1);
horizontalLayout->setStretch(2, 1);
horizontalLayout->setStretch(3, 1);
horizontalLayout->setStretch(4, 1);
verticalLayout->addLayout(horizontalLayout);
gridLayout->addLayout(verticalLayout, 0, 0, 2, 3);
SignalSlotExampleClass->setCentralWidget(centralWidget);
menuBar = new QMenuBar(SignalSlotExampleClass);
menuBar->setObjectName(QStringLiteral("menuBar"));
menuBar->setGeometry(QRect(0, 0, 600, 21));
SignalSlotExampleClass->setMenuBar(menuBar);
mainToolBar = new QToolBar(SignalSlotExampleClass);
mainToolBar->setObjectName(QStringLiteral("mainToolBar"));
SignalSlotExampleClass->addToolBar(Qt::TopToolBarArea, mainToolBar);
statusBar = new QStatusBar(SignalSlotExampleClass);
statusBar->setObjectName(QStringLiteral("statusBar"));
SignalSlotExampleClass->setStatusBar(statusBar);
retranslateUi(SignalSlotExampleClass);
QObject::connect(writeButton, SIGNAL(clicked()), SignalSlotExampleClass, SLOT(on_writeButton_clicked()));
QObject::connect(readButton, SIGNAL(clicked()), SignalSlotExampleClass, SLOT(on_readButton_clicked()));
} // setupUi
void retranslateUi(QMainWindow *SignalSlotExampleClass)
{
SignalSlotExampleClass->setWindowTitle(QApplication::translate("SignalSlotExampleClass", "SignalSlotExample", Q_NULLPTR));
progressbarLabel->setText(QApplication::translate("SignalSlotExampleClass", "Tampon Doluluk Oran\304\261 : ", Q_NULLPTR));
readButton->setText(QApplication::translate("SignalSlotExampleClass", "Oku", Q_NULLPTR));
writeButton->setText(QApplication::translate("SignalSlotExampleClass", "Yaz", Q_NULLPTR));
} // retranslateUi
};
namespace Ui {
class SignalSlotExampleClass: public Ui_SignalSlotExampleClass {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_SIGNALSLOTEXAMPLE_H

Uygulamamızın main fonksiyonu daha önce yazmış olduğumuz uygulamanın main fonksiyonu ile oldukça benzerdir:

#include “producerConsumer.h”
#include “SignalSlotExample.h”
#include <QtWidgets/QApplication>

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
SignalSlotExample w;
w.show();
return a.exec();
}

Aşağıda uygulamamızın temel sınıfı olan SignalSlotExample gösterilmiştir:

#ifndef SIGNALSLOTEXAMPLE_H
#define SIGNALSLOTEXAMPLE_H
#include <QtWidgets/QMainWindow>
#include "ui_SignalSlotExample.h"
#include "producerConsumer.h"
#include
#include <QtCore/QWaitCondition>
class SignalSlotExample : public QMainWindow
{
Q_OBJECT
public:
SignalSlotExample(QWidget *parent = Q_NULLPTR);
private:
Ui::SignalSlotExampleClass ui;
ProducerConsumerInitVariables* pc;
Producer* producer;
Consumer* consumer;
private slots:
void on_writeButton_clicked();
void on_readButton_clicked();
void onStringConsumed(const QString& text);
void onStringSizeInBuffer(int numOfBytesInBuffer);
};
#endif

SignalSlotExample sınıfı üzerinde biraz konuşmamız gerekiyor. Bu sınıfın özel (private) üyeleri Qt Desginer ile tasarlamış olduğumuz arayüz nesnesi, Producer ve Consumer sınıflarının başlangıç parametrelerinin ve ortak değişkenlerinin tutulacağı ProducerConsumerInitVariables sınıfına işaretçi, Producer ve Consumer sınıflarına birer işaretçi içermektedir.

Buton tıklamalarına cevap olarak kullanılacak olan on_writeButton_clicked ve on_readButton_clicked  fonksiyonları da yine bu sınıfta tanımlanmış özel slotlardır. Burada dikkat edeceğiniz nokta daha önce connect fonksiyonu ile aşağıda gösterilen bağlantının SignalSlotExampleClass sınıfında belirtilmiş olmasına rağmen on_writeButton_clicked fonksiyonunun tanımının SignalSlotExample sınıfında yapılmış olmasıdır.

QObject::connect(writeButton, SIGNAL(clicked()), SignalSlotExampleClass, SLOT(on_writeButton_clicked()));

Bu kafa karıştırıcı olsa da bu durum Qt’nin sinyal/slot çalışma mantığına uygundur. Burada tıklama sinyali yayınlandığında SignalSlotExampleClass sınıfının sahibi olan SignalSlotExample sınıfında tanımlanmış olan slot tarafından bu sinyal yakalanmaktadır.

Aşağıda SignalSlotExample sınıfının fonksiyon tanımlarını içeren SignalSlotExample.cpp dosyası gösterilmektedir. Bu kodu inceleyiniz devamında gerekli açıklamaları bulacaksınız.

#include "SignalSlotExample.h"
SignalSlotExample::SignalSlotExample(QWidget *parent)
: QMainWindow(parent)
{
ui.setupUi(this);
this->pc = new ProducerConsumerInitVariables();
this->producer = new Producer(this->pc, this);
this->consumer = new Consumer(this->pc, this);
QObject::connect(this->consumer, SIGNAL(stringConsumed(const QString&)), this, SLOT(onStringConsumed(const QString&)));
QObject::connect(this->producer, SIGNAL(stringSizeInBuffer(int)), this, SLOT(onStringSizeInBuffer(int)));
QObject::connect(this->consumer, SIGNAL(stringSizeInBuffer(int)), this, SLOT(onStringSizeInBuffer(int)));
}
void SignalSlotExample::on_writeButton_clicked()
{
this->producer->start();
}
void SignalSlotExample::on_readButton_clicked()
{
this->consumer->start();
}
void SignalSlotExample::onStringConsumed(const QString& text)
{
ui.bufferBrowser->insertPlainText(text);
}
void SignalSlotExample::onStringSizeInBuffer(int numOfBytesInBuffer)
{
ui.numOfCharBar->setValue(numOfBytesInBuffer);
}

Sınıfın yapıcı fonksiyonunda ilk olarak arayüzün oluşturulması için gerekli setupUi fonksiyonu çağrılıyor. Ardından ProducerConsumerInitVariables fonksiyonu çağrılarak ipliklerde kullanılacak gerekli parametreler ayarlanıyor. Consumer ve Producer iplikleri tanımlanıyor.

Daha sonra 4 tane daha sinyal/slot tanımlandığını görüyorsunuz. Önceki sinyal/slotların aksine bunları kendimiz manuel olarak oluşturduk. Aşağıda örnek olarak incelemek için bir tanesini alıntıladım:

QObject::connect(this->consumer, SIGNAL(stringConsumed(const QString&)), this, SLOT(onStringConsumed(const QString&)));

connect fonksiyonuna verilen ilk parametre sinyalin hangi nesneden kaynaklanacağını gösteriyor. İkinci parametre ise sinyalin ismidir. Sinyalin ismini verirken parametrelerin nesnenin içersindeki tanımlanan sinyal ile uyumlu olması gerektiğini unutmamamız gerekiyor. Yani bu demek oluyor ki stringConsumed sinyali Consumer sınıfından yayınlanacak. Bu konuya ipliklerin kodunu incelerken tekrar değineceğim. Üçüncü parametre ise hangi objenin bu sinyale karşı slotu barındıracağıdır. Bu uygulamada Producer ve Consumer sınıflarından yaratılan nesneler SignalSlotExample sınıfından bir nesne tarafından yakalanacak ve bu slotun ismi de yukarıdaki örnek için onStringConsumed olacaktır.

Diğer sinyal/slot bağlantılarını da bu örnek üzerinden anlamaya çalışabilirsiniz. SignalSlotExample kodunu incelemeye devam ettiğinizde slotların tanımlandığını göreceksiniz.

void SignalSlotExample::on_writeButton_clicked()
{
this->producer->start();
}

Yukarıdaki slot “Yaz” butonuna tıklandığında producer ipliğini başlatır ve bu iplik tampon belleğine bellek dolana kadar yazar.

void SignalSlotExample::on_readButton_clicked()
{
this->consumer->start();
}

Benzer şekilde yukarıdaki slot “Oku” butonuna tıklandığında consumer ipliğini başlatır ve bu iplik tampon belleğine yazılan bilgi olup olmadığını kontrol eder ve eğer önceden yazılmış veri varsa onları okur.

Okuma işlemi devam ettikçe okunan bilgiler kullanıcıya metin tarayıcı üzerine yazılarak gösterilir. Bunun için her sekizli (byte) okunduğunda aşağıdaki slot fonksiyonu çağrılır.

void SignalSlotExample::onStringConsumed(const QString& text)
{
    ui.bufferBrowser->insertPlainText(text);
}

Bellekteki doluluk oranının ilerleme çubuğu aracılığı ile takip edileceğini daha önce söylemiştim. Bunun için onStringSizeInBuffer slot fonksiyonu kullanılır. Bu slot fonksiyonu hem producer  hem de consumer tarafından çağrılır. Tampon bellekten okunan ya da yazılan her sekizli için ilerleme çubuğu güncellenir.

void SignalSlotExample::onStringSizeInBuffer(int numOfBytesInBuffer)
{
ui.numOfCharBar->setValue(numOfBytesInBuffer);
}

Aşağıda iplik (Producer ve Consumer) tanımlarının yapıldığı ve başlangıç değerlerinin tanımlandığı yapının (producerConsumerInitVariables) yer aldığı producerConsumer.h dosyası gösterilmektedir:

#ifndef PRODUCERCONSUMER_H
#define PRODUCERCONSUMER_H
#include <QtCore/QWaitCondition>
#include <QtCore/QMutex>
#include <QtCore/QThread>
#include <QtCore/QTime>
#include <QtCore/QDebug>
#define BUFFER_SIZE 256
typedef struct producerConsumerInitVariables {
const int DataSize = 1024;
char buffer[BUFFER_SIZE];;
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
QMutex mutex;
int numUsedBytes = 0;
} ProducerConsumerInitVariables;
class Producer : public QThread
{
Q_OBJECT
public:
Producer(QObject* parent = NULL) : QThread(parent)
{
this->pc = new ProducerConsumerInitVariables();
}
Producer(ProducerConsumerInitVariables *pc, QObject* parent = NULL) : QThread(parent)
{
this->pc = pc;
}
void run() override
{
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
for (int i = 0; i < pc->DataSize; ++i) {
pc->mutex.lock();
if (pc->numUsedBytes == BUFFER_SIZE) {
pc->bufferNotFull.wait(&pc->mutex);
}
pc->mutex.unlock();
pc->buffer[i % BUFFER_SIZE] = "ACGT"[(int)qrand() % 4];
pc->mutex.lock();
++pc->numUsedBytes;
pc->bufferNotEmpty.wakeAll();
pc->mutex.unlock();
emit stringSizeInBuffer(pc->numUsedBytes);
this->msleep((int)qrand() % 50);
}
}
signals:
void stringSizeInBuffer(int);
private:
ProducerConsumerInitVariables* pc;
};
class Consumer : public QThread
{
Q_OBJECT
public:
Consumer(QObject* parent = NULL) : QThread(parent)
{
}
Consumer(ProducerConsumerInitVariables* pc, QObject* parent = NULL) : QThread(parent)
{
this->pc = pc;
}
void run() override
{
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
for (int i = 0; i < pc->DataSize; ++i) {
pc->mutex.lock();
if (pc->numUsedBytes == 0) {
pc->bufferNotEmpty.wait(&pc->mutex);
}
pc->mutex.unlock();
emit stringConsumed(QString(pc->buffer[i % BUFFER_SIZE]));
pc->mutex.lock();
--pc->numUsedBytes;
pc->bufferNotFull.wakeAll();
pc->mutex.unlock();
emit stringSizeInBuffer(pc->numUsedBytes);
this->msleep((int)qrand() % 50);
}
fprintf(stderr, "\n");
}
signals:
void stringConsumed(const QString&);
void stringSizeInBuffer(int);
private:
ProducerConsumerInitVariables* pc;
};
#endif

Bir iplik tanımlama için QThread sınıfından kalıtım almalısınız ve run fonksiyonunu yeniden tanımlamalısınız. İki iplikte de yapıcı fonksiyonlar parametre olarak ipliklerin paylaştığı değişkenleri tanımlayan producerConsumerInitVariables sınıfından bir işaretçi aldığı görülecektir:

typedef struct producerConsumerInitVariables {
const int DataSize = 1024;
char buffer[BUFFER_SIZE];;
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;
QMutex mutex;
int numUsedBytes = 0;
} ProducerConsumerInitVariables;

Bu yapı içersinde yazılacak verinin boyutu, tampon bellek (buffer değişkeni), belleğin dolu ya da boş olduğunda ipliğe haber verecek olan bekleme koşulları (wait conditions), karşılıklı dışlama (muteks – ing. mutex) ve belleğin ne kadarının dolu olduğunu tutan değişkenler yer almaktadır.

Aşağıda tampon belleğe yazacak olan Producer sınıfı gösterilmektedir.

class Producer : public QThread
{
Q_OBJECT
public:
Producer(QObject* parent = NULL) : QThread(parent)
{
this->pc = new ProducerConsumerInitVariables();
}
Producer(ProducerConsumerInitVariables *pc, QObject* parent = NULL) : QThread(parent)
{
this->pc = pc;
}
void run() override
{
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
for (int i = 0; i < pc->DataSize; ++i) {
pc->mutex.lock();
if (pc->numUsedBytes == BUFFER_SIZE) {
pc->bufferNotFull.wait(&pc->mutex);
}
pc->mutex.unlock();
pc->buffer[i % BUFFER_SIZE] = "ACGT"[(int)qrand() % 4];
pc->mutex.lock();
++pc->numUsedBytes;
pc->bufferNotEmpty.wakeAll();
pc->mutex.unlock();
emit stringSizeInBuffer(pc->numUsedBytes);
this->msleep((int)qrand() % 50);
}
}
signals:
void stringSizeInBuffer(int);
private:
ProducerConsumerInitVariables* pc;
};

Bu sınıfta yer alan fonksiyonlar için gerekli tanımlamalar sınıf içerisinde yer almaktadır. Sınıfın yapıcı fonksiyonu başlangıç yapısını işaretçi ile almaktadır. run fonksiyonu ise daha önce gördüğümüz ilgili butona basıldığında çalışacak olan slot fonksiyonu tarafından başlatılacak fonksiyondur. Yani bu uygulamada kullanıcı “Yaz” butonuna basacak bu sinyal on_writeButton_clicked slotunu çalıştıracak bu slot da producer->start() fonksiyonu ile ipliği başlatacaktır. Bu iplik içerisinde ayrıca stringSizeInBuffer sinyali tanımlanmıştır. Bu sinyal de her sekizli eklendiğinde çalışacak ve ilerleme çubuğu doldurulacaktır. Aynı sinyal Consumer sınıfında da tanımlanmıştır. Consumer sınıfı da bellekten okuma yaptıkça ilerleme çubuğunu azaltacaktır. Çünkü okuma yaptıkça Producer ipliği okunan bölgeleri kullanabilecektir.

Burada bir diğer önemli yapı da bekleme koşullarıdır. Aşağıda gösterilen yapı “eğer bellek doluysa bu ipliği beklet” demektedir. Bunun için muteksin bekleme koşuluna parametre olarak verildiğine dikkat etmişsinizdir. Aşağıda muteksler hakkında bilgi verdikten sonra konuya devam edelim.


pc->mutex.lock();
if (pc->numUsedBytes == BUFFER_SIZE) {
pc->bufferNotFull.wait(&pc->mutex);
}
pc->mutex.unlock();

Muteksler iki ya da daha çok ipliğin belli bir bellek alanına ulaşımını sınırlandıran ve bu şekilde çalışmalarını düzenlememize izin veren yapılardır. Burada kullanılan bellek miktarını kontrol ettiğimiz sırada diğer iplik tarafından numUsedBytes değişkeninin değiştirilmesini engellemek istiyoruz. Değişkeni kontrol ettikten sonra eğer bellek doluysa ipliği bekletmemiz lazım fakat aynı zamanda muteksi de serbest bırakmamız gerekiyor yoksa diğer iplik de çalışmaya devam edemez. Bunun için Qt, QWaitCondition sınıfında wait fonksiyonunu sağlıyor. Bu fonksiyon çağrıldığında muteksi açıyor (unlock) ve kendi ipliğini durduruyor. Böylece diğer iplik çalışmaya devam edebilir hale geliyor. Ardından çalışan iplik kendi işini halledip bu ipliğin tekrar başlaması için sinyal yaydığında muteks tekrar kilitlenecek (lock) ve mutex.unlock() komutunu görünceye kadar ilgili alan kilitli kalacaktır.

Consumer sınıfı ise aşağıda gösterilmiştir:

class Consumer : public QThread
{
Q_OBJECT
public:
Consumer(QObject* parent = NULL) : QThread(parent)
{
}
Consumer(ProducerConsumerInitVariables* pc, QObject* parent = NULL) : QThread(parent)
{
this->pc = pc;
}
void run() override
{
qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
for (int i = 0; i < pc->DataSize; ++i) {
pc->mutex.lock();
if (pc->numUsedBytes == 0) {
pc->bufferNotEmpty.wait(&pc->mutex);
}
pc->mutex.unlock();
emit stringConsumed(QString(pc->buffer[i % BUFFER_SIZE]));
pc->mutex.lock();
--pc->numUsedBytes;
pc->bufferNotFull.wakeAll();
pc->mutex.unlock();
emit stringSizeInBuffer(pc->numUsedBytes);
this->msleep((int)qrand() % 50);
}
fprintf(stderr, "\n");
}
signals:
void stringConsumed(const QString&);
void stringSizeInBuffer(int);
private:
ProducerConsumerInitVariables* pc;
};
#endif

Bu sınıf içersinde de benzer bir muteks yapısı yer almaktadır. Bu kısmı kodu incelediğiniz takdirde çok rahat bir şekilde anlayacağınızı tahmin ediyorum. Burada yine Producer sınıfında da bulunan bir yapıyı bu sefer consumer sınıfında görelim. Daha önce eğer bellek doluysa Producer ipliğinin belleğe yazmayı bıraktığını ve beklemeye geçtiğini görmüştük. Peki Producer sınıfı bu beklemeden nasıl kurtulacak ve çalışmaya devam edecek? Burada Consumer sınıfında yer alan aşağıdaki yapı çok önemli:

pc->mutex.lock();
--pc->numUsedBytes;
pc->bufferNotFull.wakeAll();
pc->mutex.unlock();

Burada yine muteks kullanılıyor çünkü numUsedBytes değişkenine aynı anda diğer iplik tarafından erişilmesini istemiyoruz. Bu değişkeni azalttıktan sonra artık bufferNotFull bekleme durumu içersinde yer alan wakeAll fonksiyonunu kullanarak diğer ipliğin çalışmaya başlamasını sağlayabiliriz. Bu fonksiyon daha önce durdurulan ipliklerin çalışmaya başlamasını söyleyecektir çünkü bellekte artık yer açılmış oldu.

İpliklerin sonunda kullandığımız sleep fonksiyonları dikkatinizi çekmiştir:

this->msleep((int)qrand() % 50);

Bu fonksiyonu bir bilgisayarın tampon belleğine gelen verileri daha iyi simüle etmek için kullandım. Hem de bu şekilde ilerleme çubuğunda yaşanan değişimler daha net gözlenmektedir. (int)qrand() % 50 , ile 0 ile 50 arasında bir sayı rasgele üretilmektedir. Yazımız bu sefer biraz uzun oldu ama umarım okuyan herkes için faydalı olur.

arıcılık malzemeleri

Düşünceleriniz Nedir?

Lütfen yorumunuzu buraya yazınız.
Lütfen isminizi buraya yazını.

Yazar Ol arıcılık malzemeleri

Yeni Yazılar

Savaş Yönetim Sistemi

Yüzlerce yıldır süregelen harplerin galibini belirleyen en kritik unsur karar alıcılar olmuştur. En kritik zamanlarda yapılan doğru hamleler savaş kazandırmış, yanlış hamleler ise Milletlerin...

Bipolar Tedavisi Hakkında Bazı Araştırmalar

Bu makalemde bipolar bozukluk hakkında üç farklı araştırma konusuna kısa kısa değineceğim, umarım sizler için bir solukta okuyabileceğiniz faydalı bir makale olur. Konu başlıkları...

Görüntü İşleme Nedir? Nerelerde Kullanılır?

Görüntü İşleme; elde edilmiş görüntü sinyallerinin, belirli işlemlerden geçerek yeniden yapılandırılması anlamına gelir. Görüntü işlemenin temelinde pixel değerleri ile işlemler yaparak, görüntüyü daha işlevsel...

ASHRAE Derneğinin Görevleri Nelerdir

ASHRAE; Amerikan Isıtma, Soğutma ve Havalandırma Mühendisleri Derneği, ısıtma, havalandırma, klima ve soğutma sistemleri tasarım ve inşasını ilerletmek isteyen Amerikanın profesyonel bir derneğidir. ASHRAE'nin...

Mühendislik Maaşları

Makine Mühendisliği Maaşları

Yazımda internetten araştırmalar sonucu elde ettiğim makine mühendisliği maaşları hakkındaki bir takım verileri sizler ile paylaşacağım. Yorum kısmından gerçekten bu sektörde olan arkadaşlarda fikirlerini...

Endüstriyel Tasarım Mühendisliği Maaşları

Endüstriyel tasarım mühendisliği nedir ve ne iş yapar? Lise öğretiminden mezun olan öğrenciler yükseköğretime geçiş sınavına girecek ve bu bölüm endüstriyel tasarım mühendisliği maaşları...

Bilişim Sistemleri Mühendisliği Maaşları

Bilişim sistemleri mühendisi kimdir? Üniversitelerin dört yıllık eğitim veren bilişim sistemleri mühendisliği bölümünü bitiren bir kişi; basit bilgisayar programlarını tasarlayabilir, bilgisayar donanımları ile alakalı her...

Tekstil Mühendisliği Maaşları Ne Kadar

Üniversiteye hazırlanan birçok öğrenci aynı zamanda meslek dalı seçimi yapmak için de detaylı araştırmalar yapmaktadır. En fazla merak edilen meslek gruplarından bir tanesi de...