Linux线程控制课后作业

最新推荐文章于 2023-05-04 23:41:12 发布

晚月小泠

最新推荐文章于 2023-05-04 23:41:12 发布

阅读量3.3k

点赞数 12

分类专栏： Linux 课后作业操作系统

本文链接：https://blog.csdn.net/Qingyuyuehua/article/details/115873224

版权

课后作业同时被 3 个专栏收录

13 篇文章 4 订阅

订阅专栏

操作系统

10 篇文章 3 订阅

订阅专栏

Linux

8 篇文章 9 订阅

订阅专栏

1、下面函数中的哪些是线程安全函数,若不是,请将其改造成线程安全函数。哪些是可重入函数,如果不是,请给出原因?

（1）

void strcpy( char " IpszDest, char * lpszSrc)
{
	while(*lpszDest++ = *lpszSrc++) { }
}

（2）

static int sum value = 0:
void sum_counter()
{
	sum_valuet+;
}

（3）

char * strtoupper( char * string)
{
    static char buffer[MAX_STRING_SIZE]; 
    int index;
	for(index= 0; string[index]; index++) 
        buffer[index]=toupper(string[index]);
	buffer[index]=0;
	return buffer;
}

（4）

extern unsigned char key;
void ciphher(char*str)
{
    int i;
	for(i= 0;str[i]; i++)
		str[i]=(str[i]+key)%256;
	key=(key+1)%256;
}

（1）可重入函数，没有共享变量，且为线程安全函数。

（2）不是线程安全函数，因为sum_value是共享变量且不加以保护。

改写：

semaphore mutex = 1;
static int num_value = 0;
void sum_counter()
{
	Wait(mutex);
	sum_value++;
	Signal(mutex);
}

（3）static定义的静态变量在函数中为共享变量，且没有信号量控制，故不是线程安全函数。

改写

char* strtoupper(char * string)
{
	char buffer[MAX_STRING_SIZE];
	int index;
	for(index = 0; string[index]; index++)
		buffer[index]=toupper(string[index]);
	buffer[index] = 0;
	return buffer;
}

（4）key为全局的共享变量，且在程序中被多个线程读写，故不是线程安全函数。

改写：

semaphore mutex = 1;
extern unsigned char key; 
void ciphher(char *str)
{
   	int i;
	Wait(mutex);
	for(i=0; str[i]; i++) 
	str[i]=(str[i]+key) % 256;
	key=(key+1) % 256;
	Signal(mutex);
}

2、编写程序thread file .c,该程序创建两个线程,一个线程负责从文件+ stat.c 读入数据,另一个线程负责显示读出的文件内容。请注意读文件线程如何将文件结束标准传递给显示线程。

#include <iostream>
#include <fstream>
#include <pthread.h>
#include <semaphore.h>

using namespace std;

void *readFile(void *args);
void *writeFile(void *args);

ifstream fin;//文件流对象
string buf;//读写共享缓冲区
sem_t empty;//信号量empty
sem_t have;//信号量have

int main()
{
    fin.open("data.txt", ios_base::in);//打开文件
    sem_init(&empty, 0, 1);
    sem_init(&have, 0, 0);
    pthread_t tid1, tid2;

    pthread_create(&tid1, NULL, readFile, NULL);
    pthread_create(&tid2, NULL, writeFile, NULL);

    sem_destroy(&empty);
    sem_destroy(&have);

    return 0;
}

void *readFile(void *args)
{
    while (!fin.eof())
    {
        sem_wait(&empty);
        getline(fin, buf);
        sem_post(&have);
    }
}

void *writeFile(void *args)
{
    while (1)
    {
        sem_wait(&have);
        cout << buf << endl;
        sem_post(&empty);
    }
}

3、编写N×L与LM矩阵乘法函数的并行线程化版本,与顺序版本的性能做比较,计算在2核CPU和4核CPU上运行时的加速比和效率。

代码：

//Mairix.h
#ifndef MATRIX_H
#define MAIRIX_H
#include <iostream>
#include <pthread.h>
class Matrix
{
public:
    Matrix(int M, int N);
    Matrix(int M, int N, int **d);
    ~Matrix();
    bool set(int M, int N, int num);
    int get(int M, int N) { return *(*(data + M) + N); }
    void print() const;
    friend Matrix *multiplication(const Matrix *m1, const Matrix *m2);
    friend int calculation(const Matrix &m1, int l, const Matrix &m2, int r);

private:
    int line;   //行数
    int row;    //列树
    int **data; //数据数组
};

struct ThreadArgs
{
    const Matrix *mar1;
    int m1Line;
    const Matrix *mar2;
    int m2Row;

public:
    ThreadArgs(const Matrix *m1, int l, const Matrix *m2, int r) : mar1(m1), m1Line(l), mar2(m2), m2Row(r) {}
};

void *pcalculation(void *args);

#endif

//Mairix.cpp
#include "Matrix.h"

Matrix::Matrix(int M, int N) : line(M), row(N), data(nullptr)
{
    data = new int *[M];
    for (int i = 0; i < M; i++)
    {
        *(data + i) = new int[N];
    }
    for (int i = 0; i < line; i++)
        for (int j = 0; j < row; j++)
            *(*(data + i) + j) = 0;
}

Matrix::Matrix(int M, int N, int **d)
{
    data = new int *[M];
    for (int i = 0; i < M; i++)
    {
        *(data + i) = new int[N];
    }
    for (int i = 0; i < line; i++)
        for (int j = 0; j < row; j++)
        {
            std::cout << *(*(d + i) + j) << " ";
            *(*(data + i) + j) = *(*(d + i) + j);
        }
}

Matrix::~Matrix()
{
    for (int i = 0; i < line; i++)
    {
        delete[] * (data + i);
    }
    delete[] data;
}

bool Matrix::set(int M, int N, int num)
{
    if (M < 0 || M >= line || N < 0 || N >= row)
        return false;
    *(*(data + M) + N) = num;
    return true;
}

void Matrix::print() const
{
    for (int i = 0; i < line; i++)
    {
        for (int j = 0; j < row; j++)
            std::cout << *(*(data + i) + j) << " ";
        std::cout << std::endl;
    }
}

Matrix *multiplication(const Matrix *m1, const Matrix *m2)
{
    int allnum = m1->line * m2->row;
    Matrix *newMartrix = new Matrix(m1->line, m2->row);
    pthread_t *tids = new pthread_t[allnum];
    int k = 0;

    for (int i = 0; i < m1->line; i++)
    {
        for (int j = 0; j < m2->row; j++)
        {
            ThreadArgs temp = ThreadArgs(m1, i, m2, j);
            pthread_create((tids + k), 0, pcalculation, (void *)&(temp));
            k++;
        }
    }

    k = 0;
    int temps;
    for (int i = 0; i < m1->line; i++)
    {
        for (int j = 0; j < m2->row; j++)
        {
            pthread_join(*(tids + k), (void **)&temps);
            k++;
            newMartrix->set(i, j, (int)(temps));
        }
    }
    delete[] tids;
    return newMartrix;
}

int calculation(const Matrix &m1, int l, const Matrix &m2, int r)
{
    int sum = 0;
    for (int i = 0; i < m1.row; i++)
    {
        sum += (*(*(m1.data + l) + i)) * (*(*(m2.data + i) + r));
    }
    return sum;
}

void *pcalculation(void *args)
{
    ThreadArgs *Targs = (ThreadArgs *)args;
    int res = calculation(*(Targs->mar1), Targs->m1Line, *(Targs->mar2), Targs->m2Row);
    pthread_exit((void *)*&res);
}

//main.cpp
#include <iostream>
#include <memory>
#include "Matrix.h"

using namespace std;

//测试数据一的行数和列数
const int TESTLINE1 = 3;
const int TESTROW1 = 4;

//测试数据二的行数和列数
const int TESTLINE2 = 4;
const int TESTROW2 = 5;

int main()
{
    //设置测试数据
    int testdata1[TESTLINE1][TESTROW1]{
        {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 0, 1, 2}};
    int testdata2[TESTLINE2][TESTROW2]{
        {1, 2, 3, 4, 5}, {5, 6, 7, 8, 9}, {9, 0, 1, 2, 3}, {3, 4, 5, 6, 7}};
    //建立矩阵类
    Matrix matr1(TESTLINE1, TESTROW1);
    Matrix matr2(TESTLINE2, TESTROW2);
    //导入测试数据
    for (int i = 0; i < TESTLINE1; i++)
        for (int j = 0; j < TESTROW1; j++)
            matr1.set(i, j, testdata1[i][j]);
    for (int i = 0; i < TESTLINE2; i++)
        for (int j = 0; j < TESTROW2; j++)
            matr2.set(i, j, testdata2[i][j]);

    //打印测试输入
    cout << "矩阵一" << endl;
    matr1.print();
    cout << "矩阵二" << endl;
    matr2.print();
    //计算乘法，并把结果存储
    shared_ptr<Matrix> res(multiplication(&matr1, &matr2));
    //输出结果
    cout << "输出结果" << endl;
    res->print();
    return 0;
}

4、基于线程技术编写程序square .c,计算整型数组a[N]中各元素的平方和sum=a1a1+a2a2++an*an,并测量CPU数为1、2、4、8、16时的加速比。

//Square.h
#ifndef SQUARE_H
#define SQUARE_H
#include <iostream>
#include <pthread.h>

class Square
{
public:
    Square(int s);
    ~Square();
    void set(int s, int n);
    int get(int s);
    void print() const;
    friend int SumOfSquares(const Square &squ, int s);
    friend int calculation(const Square &squ, int n);

private:
    int size;
    int *data;
};

struct ThreadArgs
{
    const Square *squ1;
    int size;

public:
    ThreadArgs(const Square *squ, int s) : squ1(squ), size(s) {}
};

void *pcalculation(void *args);

#endif

//Square.cpp
#include "Square.h"

Square::Square(int s) : size(s), data(nullptr)
{
    data = new int[s];
    for (int i = 0; i < size; i++)
        *(data + i) = 0;
}

Square::~Square()
{
    delete[] data;
}

void Square::set(int s, int n)
{
    if (s < 0 || s >= size)
        return;
    *(data + s) = n;
}

int Square::get(int s)
{
    if (s < 0 || s >= size)
        return 0;
    return *(data + s);
}

void Square::print() const
{
    for (int i = 0; i < size; i++)
        std::cout << *(data + i) << " ";
    std::cout << std::endl;
}

int SumOfSquares(const Square &squ, int s)
{
    pthread_t *tids = new pthread_t[s];

    for (int i = 0; i < s; i++)
    {
        ThreadArgs temp = ThreadArgs(&squ, i);
        pthread_create((tids + i), 0, pcalculation, (void *)&(temp));
    }

    int sum = 0;
    int temps;
    for (int i = 0; i < s; i++)
    {
        pthread_join(*(tids + i), (void **)&temps);
        sum += (int)(temps);
    }
    return sum;
}

int calculation(const Square &squ, int n)
{
    int res = squ.data[n] * squ.data[n];
    return res;
}

void *pcalculation(void *args)
{
    ThreadArgs *Targs = (ThreadArgs *)args;
    int res = calculation(*(Targs->squ1), Targs->size);
    pthread_exit((void *)*&res);
}

//main.cpp
#include <iostream>
#include <memory>
#include "Square.h"

using namespace std;

//测试数据的个数
const int SIZE = 10;

int main()
{
    //设置测试数据
    int testdata[SIZE]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    //建立矩阵类
    Square sqr(SIZE);
    //导入测试数据
    for (int i = 0; i < SIZE; i++)
        sqr.set(i, testdata[i]);

    //打印测试输入
    cout << "数据" << endl;
    sqr.print();

    //计算平方和并把结果存储
    int sum = SumOfSquares(sqr, SIZE);
    //输出结果
    cout << "输出结果" << endl;
    cout << "sum = " << sum << endl;
    return 0;
}

5、Provide two programming examples in which multithreading does not provide better performance than a single-threaded solution.提供两个编程示例，其中多线程不能提供比单线程解决方案更好的性能。

任何形式的顺序程序都不适合多线程，如报酬计算程序，需要监控运行的程序

6、Provide two programming examples in which multithreading provides better performance than a single-threaded solution.提供两个编程示例，其中多线程比单线程解决方案提供更好的性能。

矩阵计算，平方和计算

7、Which of the following components of program state are shared across threads in a multithreaded process?在多线程进程中，程序状态的以下哪些组件是跨线程共享的？

a. Register values 寄存器值
b. Heap memory 堆内存
c. Global variables 全局变量
d. Stack memory 堆栈存储器

b、c

8、The program shown in Figure 4.16 uses the Pthreads API. What would be the output from the program at LINE C and LINE P?图4.16所示的程序使用pthreads api。C行和P行程序的输出是什么？

在这里插入图片描述

line c: child: value = 5

line p parent: value = 0

9、

在这里插入图片描述

#include <iostream>
#include <vector>

using namespace std;

struct Arg
{
    int *ins;
    int size;
    Arg(int *i, int s) : ins(i), size(s) {}
};

void *ave(void *args);
void *max(void *args);
void *min(void *args);

int main()
{
    pthread_t tid[3];
    int ins[7]{90, 81, 78, 95, 79, 72, 85};
    Arg arg(ins, 7);
    pthread_create(&tid[0], nullptr, ave, (void *)&arg);
    pthread_create(&tid[1], nullptr, max, (void *)&arg);
    pthread_create(&tid[2], nullptr, min, (void *)&arg);

    int aves, maxs, mins;
    pthread_join(tid[0], (void **)&aves);
    pthread_join(tid[1], (void **)&maxs);
    pthread_join(tid[2], (void **)&mins);
    cout << "ave = " << aves << endl;
    cout << "max = " << maxs << endl;
    cout << "min = " << mins << endl;
    return 0;
}

void *ave(void *args)
{
    int temp = 0;
    Arg *arg = (Arg *)args;
    for (int i = 0; i < arg->size; i++)
    {
        temp += *(arg->ins + i);
    }
    temp = temp / arg->size;
    pthread_exit((void *)temp);
}

void *max(void *args)
{
    int temp = 0;
    Arg *arg = (Arg *)args;
    for (int i = 0; i < arg->size; i++)
    {
        if (*(arg->ins + i) > temp)
            temp = *(arg->ins + i);
    }
    pthread_exit((void *)temp);
}

void *min(void *args)
{
    Arg *arg = (Arg *)args;
    int temp = *(arg->ins);
    for (int i = 1; i < arg->size; i++)
    {
        if (*(arg->ins + i) < temp)
            temp = *(arg->ins + i);
    }
    pthread_exit((void *)temp);
}

在这里插入图片描述

晚月小泠

关注

12
点赞
踩
24

收藏

觉得还不错? 一键收藏
4
评论
Linux线程控制课后作业

1、下面函数中的哪些是线程安全函数,若不是,请将其改造成线程安全函数。哪些是可重入函数,如果不是,请给出原因?（1）void strcpy( char " IpszDest, char * lpszSrc){ while(*lpszDest++ = *lpszSrc++) { }}（2）static int sum value = 0:void sum_counter(){ sum_valuet+;}（3）char * strtoupper( char * string){
复制链接

扫一扫

专栏目录