[简单多线程控制]_[模拟杀毒软件线程控制]

场景:

1.在做业务库时,目前有2种常见的状态，开始，停止。假如需要增加一个暂停状态的话。就需要线程控制。

要求:

1.参考杀毒的开始杀毒，继续杀毒，暂停杀毒，停止杀毒4个状态设计一个多线程程序。主线程控制工作线程的暂停，继续和停止。注意，只能两个线程,注意，工作线程只能是detach，不能是join,因为主线程不能被挂起.

2.必须使用pthread线程来实现(网站研发的可以用.net自带线程库)，有时间自己可以实现win32版本。写一个控制台或界面程序，界面程序可以模仿例子的，控制台程序可以输入数字来代替按钮按下。如:

1.开始扫描.

2.继续扫描->暂停扫描切换.

3.停止扫描.

#include <stdio.h>
#include <iostream>

#include "pthread.h"

typedef enum ButtonType
{
kStart = 0,  //开始
kPause,  //暂停
kStop,  //停止
kContinue,  //继续
}ButtonType;

typedef struct ThreadData
{
ButtonType type_;
pthread_mutex_t mutex_;
pthread_cond_t mian_cv_;
pthread_cond_t work_cv_;
}ThreadData;

void *WorkThread(void *data)
{
ThreadData *user_data = (ThreadData *)data;
while (1)
{
switch (user_data->type_)
{
case kPause:
{
Sleep(1000);
pthread_mutex_lock(&user_data->mutex_);
//告诉主线程可以继续
pthread_cond_signal(&user_data->mian_cv_);
//线程阻塞

pthread_cond_wait(&user_data->work_cv_, &user_data->mutex_);

pthread_mutex_unlock(&user_data->mutex_);

if(user_data->type_ == kContinue)
{
pthread_mutex_lock(&user_data->mutex_);
pthread_cond_signal(&user_data->mian_cv_);
pthread_mutex_unlock(&user_data->mutex_);
}

//pause
if (user_data->type_ == kStop)
{
pthread_mutex_lock(&user_data->mutex_);
pthread_cond_signal(&user_data->mian_cv_);
pthread_mutex_unlock(&user_data->mutex_);
return 0;
}

break;
}
case kStop:
{
//告诉主线程可以继续
pthread_mutex_lock(&user_data->mutex_);
pthread_cond_signal(&user_data->mian_cv_);
pthread_mutex_unlock(&user_data->mutex_);

//结束进程
return 0;
}
default:
{
break;
}
}

//Sleep(1000);
}
}

void PrintHelp()
{
std::cout<<"0  start"<<std::endl;
std::cout<<"1  pause<->continue"<<std::endl;
std::cout<<"2  stop"<<std::endl;
std::cout<<"q  quit"<<std::endl;
}

//开始状态只能一次
//暂停<->继续->停止
//当工作线程处于正确状态时，主线程可以工作别的
//主线程控制工作线程状态
int main(int argc, char *argv[])
{

ThreadData data;
data.type_ = kStop;
pthread_cond_init(&data.mian_cv_, NULL);
pthread_cond_init(&data.work_cv_, NULL);

pthread_mutex_init(&data.mutex_, NULL);

//打印帮助信息
PrintHelp();

int value;
while (1)
{
value = getchar();
switch (value)
{
case '0':  //0  start
{
if (data.type_ != kStop)
{
std::cout<<"already start !"<<std::endl;
break;
}

std::cout<<"start"<<std::endl;
data.type_ = kStart;
pthread_t id;
pthread_create(&id, NULL, WorkThread, (void *)&data);
pthread_detach(id);
break;
}
case '1':  //1  pause<->continue
{
if (data.type_ == kStop)
{
std::cout<<"not start !"<<std::endl;
break;
}

pthread_mutex_lock(&data.mutex_);
if (data.type_ == kPause)
{
std::cout<<"cotinue"<<std::endl;
data.type_ = kContinue;
pthread_cond_signal(&data.work_cv_);
}
else
{
std::cout<<"pause"<<std::endl;
data.type_ = kPause;
}

pthread_cond_wait(&data.mian_cv_, &data.mutex_);
pthread_mutex_unlock(&data.mutex_);
break;
}
case '2':  //2  stop
{
if (data.type_ == kStop)
{
std::cout<<"already finish !"<<std::endl;
break;
}

std::cout<<"stop"<<std::endl;
pthread_mutex_lock(&data.mutex_);

pthread_cond_signal(&data.work_cv_);
data.type_ = kStop;
pthread_cond_wait(&data.mian_cv_, &data.mutex_);
pthread_mutex_unlock(&data.mutex_);
break;
}
case 'q':  //quit
break;
default:
break;
}

if (value == 'q')
{
break;
}
}

pthread_cond_destroy(&data.mian_cv_);
pthread_cond_destroy(&data.work_cv_);
pthread_mutex_destroy(&data.mutex_);

return 0;
}

参考文章：

/article/2144617.html