2133213

#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include<time.h>
#include <sys/sem.h>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <queue>
#include <stdlib.h>
#include <pthread.h>
#include <stack>
#include <sys/types.h>
#include <sys/ipc.h>
#include "../header/header.h"
#include <sys/shm.h>
using namespace std;
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;

union semun {
 
        int val; /* value for SETVAL */
 
        struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
 
        unsigned short *array; /* array for GETALL, SETALL */
 
        struct seminfo *__buf; /* buffer for IPC_INFO */
 
        };
class Task{
private:
    string name;
    double size;
    int priority;
public:
    bool operator<(const Task& task) const{
        if(this->priority == task.priority){
            return this->size > task.size;
        }
        else{
            return this->priority > task.priority;
        }
    }

    Task(const string &name, double size, int priority) : name(name), size(size), priority(priority) {}

    const string &getName() const {
        return name;
    }

    void setName(const string &name) {
        Task::name = name;
    }

    double getSize() const {
        return size;
    }

    void setSize(double size) {
        Task::size = size;
    }

    int getPriority() const {
        return priority;
    }

    Task() {
        this->priority = 0;
        this->size = 0;
        this->name = "";
    }

    void setPriority(int prior) {
        Task::priority = prior;
    }
};
class PrintQueue{
public:
    void push(Task task){
        this->printqueue.push(task);
    }
    Task top(){
        return this->printqueue.top();
    }
    void pop(){
        this->printqueue.pop();
    }
    size_t size(){
        return this->printqueue.size();
    }
    bool empty(){
        return this->printqueue.size() == 0;
    }
private:
    priority_queue<Task> printqueue;
};
int key;
int semid;
union semun arg;
int flag ;
PrintQueue printQueue;
int ret;
int print_ret;

/***对信号量数组semnum编号的信号量做P操作***/
int P(int semid, int semnum)
{
    struct sembuf sops={semnum,-1, SEM_UNDO};
    return (semop(semid,&sops,1));
}


/***对信号量数组semnum编号的信号量做V操作***/
int V(int semid, int semnum)
 
{
 
    struct sembuf sops={semnum,+1, SEM_UNDO}; // semundo避免造成死锁

    return (semop(semid,&sops,1));
 
}
void InsertTask(PrintQueue* printque,Task& task){
    if(pthread_mutex_lock(&mutx) != 0)
    {
        perror("pthread_mutex_lock");
        exit(EXIT_FAILURE);
    }
    // 加锁成功
    if (P(semid, 0) < 0)
    {
        perror("P operate error,资源未上锁") ;
        return;
    }
    cout << "获取锁了，正在进行插入" << endl;
    printque->push(task);
    sleep(5);
    cout << "释放" << endl;
    if(pthread_mutex_unlock(&mutx) != 0)
    {
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
    }
    //退锁
    if (V(semid, 0) < 0)
    {
        perror("P operate error,资源未释放") ;
        return;
    }
}

// 删除打印任务，同时必须使其他试图执行打印以及添加任务的线程阻塞
void delete_task(PrintQueue* que,string name){
    if (P(semid, 0) < 0)
    {
        perror("P operate error,其他进程未休眠");
        return;
    }
    if(pthread_mutex_lock(&mutx) != 0)
    {
        perror("pthread_mutex_lock");
        exit(EXIT_FAILURE);
    }
    PrintQueue* temp_queue;
    bool if_found = false;
    cout << "正在删除名称为" << name << "的打印任务" << endl;
    for (size_t i = 0; i < que->size(); ++i) {
        if(que->top().getName() == name)
        {
            if_found = true;
            que->pop();
            break;
        }
        temp_queue->push(printQueue.top());
        que->pop();
    }
    if(!temp_queue->empty())
    {
        que->push(temp_queue->top());
        temp_queue->pop();
    }
    if(!if_found)
    {
        cout << "未找到对应的打印任务"<<endl;
    }
    if(pthread_mutex_unlock(&mutx) != 0)
    {
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
    }
    if (V(semid, 0) < 0)
    {
        perror("V operate error,其他进程未唤醒") ;
        return ;
    }
    
}

void  DoPrint(PrintQueue* que){
    if (P(semid, 0) < 0)
    {
        perror("P operate error,其他进程未休眠") ;
        return ;
    }
    if(pthread_mutex_lock(&mutx) != 0)
    {
        perror("pthread_mutex_lock");
        exit(EXIT_FAILURE);
    }
    
    Task task = que->top();
    cout << "正在打印" << task.getName() << "的内容，" << "大小为" << task.getSize() << "KB" << endl;
    cout << "[";
    auto t1 = clock();
    for(int i=0;i<100;i++)
    {
        sleep(0.01);
        cout << (char)0xa8 << (char)0x80;
    }
    auto t2 = clock();
    cout << "] 100%" <<endl;
    cout << "打印耗时" << (t2 - t1) / 1000 << "s"<< endl;
    que->pop();
    if (V(semid, 0) < 0)
    {
        perror("P operate error,其他进程未唤醒") ;
        return ;
    }
    if(pthread_mutex_unlock(&mutx) != 0)
    {
        perror("pthread_mutex_unlock");
        exit(EXIT_FAILURE);
    }
    //释放锁
}
void Print_Ongoing_Task(PrintQueue* que){
    if (P(semid, 0) < 0)
    {
        perror("P operate error,其他进程未休眠") ;
        return ;
    }
    if(pthread_mutex_lock(&mutx) != 0)
    {
        perror("pthread_mutex_lock failed");
        exit(EXIT_FAILURE);
    }
    PrintQueue* temp_queue;
    size_t size = que->size();
    for (int i = 0; i < size; ++i) {
        printf("第%d个打印任务是%s,大小为%f,优先级为%d",i,que->top().getName().c_str(),que->top().getSize(),que->top().getPriority());
        temp_queue->push(que->top());
        sleep(1);
        cout << "打印完成!" << endl;
        que->pop();
    }
    que = temp_queue;
    if(pthread_mutex_unlock(&mutx) != 0)
    {
        perror("pthread_mutex_unlock failed");
        exit(EXIT_FAILURE);
    }
     if (V(semid, 0) < 0)
    {
        perror("P operate error,其他进程未唤醒") ;
        return ;
    }
}

int main(int argc, char **argv)
 
{
    struct sembuf semop;
    key = ftok("/tmp", 0x66 ) ;
    if ( key < 0 )
    {
        perror("ftok key error") ;
        return -1 ;
    }

    /***本程序创建了三个信号量，实际使用时只用了一个0号信号量***/
    semid = semget(key,3,IPC_CREAT|0600);

    if (semid == -1)
    {
        perror("create semget error");
        return 0;
    }

    if ( argc == 1 )
    {
        arg.val = 1;
        /***对0号信号量设置初始值***/
        ret =semctl(semid,0,SETVAL,arg);
        if (ret < 0 )
        {
            perror("ctl sem error");
            semctl(semid,0,IPC_RMID,arg);
            return -1 ;
        }
    }
    cout << "程序初始化: ";
    system("date");
    string name;;
    double size;
    int prior;
    Task task;
    pid_t pid;
    key_t  key_n ;
    int shm_id;
    void *shm = NULL;
    char buf[1024+1];
    PrintQueue* que;
    if((key_n = ftok("/",'s')<0))  //生成共享内存的key值
    {
        perror("Fail to ftok");
        exit(EXIT_SUCCESS);
    }
    printf("key num:%d\n",key_n);
 
    if((shm_id = shmget(key_n,1024,0666|IPC_CREAT))==-1)  //创建共享内存
    {
        perror("Fail to shmget");
        exit(EXIT_SUCCESS);
    }
    while(true){
        cout << "请输入你要进行的操作: 1:新增打印任务; 2: 删除打印任务; 3:查看打印任务完成情况 ;4: 开始打印; 0: 退出程序"<< endl;
        int cmd;
        cin >> cmd;
        switch (cmd) {
            case 1:
                cout << "请输入名字"<<endl;
                cin >>name;
                cout <<"请输入大小"<<endl;
                cin >> size;
                cout << "请输入优先级"<< endl;
                cin >>prior;
                task = Task(name,size,prior);
                pid = fork();
                if(pid < 0)
                {
                    perror("fork"); //错误处理
                    exit(1);
                }
                else if(pid == 0)
                {
                    shm = shmat(shm_id,0,0);
                    if(shm==(void *)-1)
                    {
                        perror("Fail to shmat");
                        exit(EXIT_SUCCESS);
                    }
                    que = (PrintQueue*) shm;
                    
                    InsertTask(que,task);
                    exit(0);
                }
                else
                {
                    int status = 0;
                    pid_t res = waitpid(pid, &status, 0); //阻塞式等待
                    if(res > 0) //等待子进程运行成功
                    {
                        printf("\n");
                        printf("插入程序运行结果 Running Code: %d \n", WEXITSTATUS(status));
                        
                    }
                }
                break;
            case 2:
                cout <<"请输入你要删除的打印任务的名称" <<endl;
                cin >> name;
                pid = fork();
                if(pid < 0)
                {
                    perror("fork"); //错误处理
                    exit(1);
                }
                else if(pid == 0)
                {
                    shm = shmat(shm_id,0,0);
                    if(shm==(void *)-1)
                    {
                        perror("Fail to shmat");
                        exit(EXIT_SUCCESS);
                    }
                    que = (PrintQueue*) shm;
                    
                   delete_task(que,name);
                   exit(1);
                }
                else
                {
                    int status = 0;
                    pid_t res = waitpid(-1, &status, 0); //阻塞式等待
                    if(res > 0) //等待子进程运行成功
                    {
                        printf("\n");
                        printf("删除程序运行结果 Running Code: %d \n", WEXITSTATUS(status));
                    }
                }
                break;
            case 3:
                pid = fork();
                if(pid < 0)
                {
                    perror("fork"); //错误处理
                    exit(2);
                }
                else if(pid == 0)
                {
                    shm = shmat(shm_id,0,0);
                    if(shm==(void *)-1)
                    {
                        perror("Fail to shmat");
                        exit(EXIT_SUCCESS);
                    }
                    que = (PrintQueue*) shm;
                   Print_Ongoing_Task(que);
                   return 1;
                }
                else
                {
                    int status = 0;
                    pid_t res = waitpid(-1, &status, 0); //阻塞式等待
                    if(res > 0) //等待子进程运行成功
                    {
                        printf("\n");
                        printf("观察打印队列程序运行结果 Running Code: %d \n", WEXITSTATUS(status));
                    }
                }
                break;
            case 4:
                pid = fork();
                if(pid < 0)
                {
                    perror("fork"); //错误处理
                    exit(1);
                }
                else if(pid == 0)
                {
                    shm = shmat(shm_id,0,0);
                    if(shm==(void *)-1)
                    {
                        perror("Fail to shmat");
                        exit(EXIT_SUCCESS);
                    }
                    que = (PrintQueue*) shm;
                   DoPrint(que);
                   exit(3);
                }
                else
                {
                    int status = 0;
                    pid_t res = waitpid(-1, &status, 0); //阻塞式等待
                    if(res > 0) //等待子进程运行成功
                    {
                        printf("\n");
                        printf("打印程序运行结果 Running Code: %d \n", WEXITSTATUS(status));
                    }
                }
                break;
            case 0:
                exit(0);
                break;
            default:
                break;
        }
    }
    if ( argc >1 )
    {
        semctl(semid,0,IPC_RMID,arg); //删除信号量集合
    }
    return 0 ;
 
}