操作系统作业4

灰太狼 2021-12-24 03:11 474阅读 0赞

**第四章作业**

**4.1**

题目：Provide three programming examples in which multithreading provides better performance than a single-threaded solution.

回答：

1.  一个Web服务器接收到对网页、图片、声音等的客户端请求。流量比较高的服务器可能同时有很多客户端访问它。如果Web服务器作为一个传统的单线程进程运行，那么它同时只能够响应一个客户端。客户端等待服务的时间可能会非常**长**。通常比较高效的方法是**创建一个包含了多个线程的进程**来服务同样的请求。这种方法将使web服务进程**多线程化**。服务器将创建一个独立的线程来监听客户端请求；当一个请求产生时，它就创建另一个线程来服务这个请求，而不是创建一个进程。
2.  线程在远程过程调用（RPC）系统中也起着至关重要的作用。RPC通过提供类似于普通函数或过程调用的通信机制来允许进程间通信。通常，RPC服务器是多线程的。当服务器接收到消息时，它使用单独的线程来服务消息。这允许服务器**为多个并发请求服务**。
3.  字处理软件：如果只有一个进程，当你去编辑，去输入的时候，那么排版的工作就做不了，也不能去存盘。因此，通常会在录入输入一些文档的过程中再派生出其他的线程来完成其他的任务。也就是在一个字处理软件的进程当中派生出其他的任务。一个任务完成的是管理键盘的**输入**，如果删除某一行，那么文档就需要重新做**排版**，那么专门有一个任务是用来做排版的。如果为了工作不丢失，会**启动定时保存**，到点之后这个任务就开始工作，把相应的内容保存在磁盘上。

**4.2**

题目：What are two differences between user-level threads and kernel-level threads? Under what circumstances is one type better than the other?

回答：

用户线程：

内核线程：

**区别：**

<table style="margin-left:6.75pt;width:389.6pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:233.65pt;"> 用户级线程 </td> 
 <td style="vertical-align:top;width:155.95pt;"> 内核级线程 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:233.65pt;"> 内核不知道用户级线程的存在 </td> 
 <td style="vertical-align:top;width:155.95pt;"> 内核已知内核级线程的存在 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:233.65pt;"> 在没有内核支持的情况下管理用户级线程 </td> 
 <td style="vertical-align:top;width:155.95pt;"> 内核级线程由操作系统管理 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:233.65pt;"> 用户级线程由线程库调度 </td> 
 <td style="vertical-align:top;width:155.95pt;"> 内核级线程由内核调度 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:233.65pt;"> 用户级线程创建的速度更快 </td> 
 <td style="vertical-align:top;width:155.95pt;"> 慢 </td> 
 </tr> 
 </tbody> 
</table>

**内核级线程优于用户级线程的情况**：

如果内核是**单线程**的，那么内核级线程优于用户级线程，因为执行阻塞系统调用的任何用户级线程都将导致整个进程阻塞，即使其他线程在应用程序中可以运行。

在**多处理器环境**中，内核级线程优于用户级线程，因为内核级线程可以同时在不同的处理器上运行，而进程的用户级线程只在一个处理器上运行，即使多个处理器可用。

**用户级线程优于内核级线程的情况**：

如果内核是**时间共享的**，那么用户级线程比内核级线程更好，因为在时间共享系统中，上下文切换频繁发生。内核级线程之间的上下文切换开销很高，几乎与进程相同，而用户级线程之间的上下文切换与内核级线程相比几乎没有开销。

**4.3**

题目：Describe the actions taken by a kernel to context-switch between kernel- level threads.

回答：

首先，从正在切换的线程中保存CPU寄存器的值

其次，恢复正在调度的新线程的CPU寄存器。

**4.5**

题目：Assume that an operating system maps user-level threads to the kernel using the many-to-many model and that the mapping is done through LWPs. Furthermore, the system allows developers to create real-time threads for use in real-time systems. Is it necessary to bind a real-time thread to an LWP? Explain.

回答：需要——如果一个real-time thread没有绑定到LWP，那么该线程在运行之前必须先连接到LWP。

当LWP绑定到某个线程之后，这个线程**优先级将会变得更高**。在死锁情况下，如果一个线程有LWP，这个线程将以最小延迟运行来节省时间。

所以，通过将LWP绑定到实时线程来确保线程一旦调度就能够以**最小延迟**运行。

**4.8**

题目：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

回答：bc

a. Register values

**b. Heap memory**

**c. Global variables**

d. Stack memory

堆内存和全局变量在多线程进程中共享。在多线程过程中，每个线程都有自己的堆栈和寄存器值。

**4.12**

题目：Using Amdahl’s Law, calculate the speedup gain of an application that has a 60 percent parallel component for (a) two processing cores and (b) four processing cores.

回答：

1.  two processing cores

1/(0.4 + (1-0.4)/2=1.429

1.  four processing cores.

1/(0.4 + (1-0.4)/4)=1.818

**4.14**

题目：A system with two dual-core processors has four processors available for scheduling. A CPU-intensive application is running on this system. All input is performed at program start-up, when a single file must be opened. Similarly, all output is performed just before the program terminates, when the program results must be written to a single file. Between startup and termination, the program is entirely CPU- bound. Your task is to improve the performance of this application by multithreading it. The application runs on a system that uses the one-to-one threading model (each user thread maps to a kernel thread).

• How many threads will you create to perform the input and output? Explain.

• How many threads will you create for the CPU-intensive portion of the application? Explain.

/\*一个具有两个双核处理器的系统有四个处理器可用于调度。CPU密集型应用程序正在这个系统上运行。所有输入都是在程序启动时执行的，这时必须打开一个文件。类似地，所有输出都在程序终止之前执行，当程序结果必须写入单个文件时。在启动和终止之间，程序完全是CPU绑定的。您的任务是通过多线程来提高这个应用程序的性能。应用程序运行在使用一对一线程模型（每个用户线程映射到内核线程）的系统上。

你将创建多少线程来执行输入和输出？解释。

你将为应用程序的CPU密集型部分创建多少线程？解释。\*/

回答：

线程数取决于应用程序的优先级和要求。

因此，对于这种应用程序，只有线程足够了，这个线程将同时处理输入和输出操作——并发，关键点是创建与阻塞系统调用数相同的线程，因为线程将被用来阻塞。

而创建额外的线程也没啥益处。

因此，创建**一个**线程来执行输入，**一个**进程来执行输出。

创建**四个线程**来执行应用程序的CPU密集型部分。

因为：线程数应该和处理核数相同。

如果线程数比4小，会浪费处理资源。

而大于4个线程就不能运行。

**4.15**

题目：Consider the following code segment:

a. How many unique processes are created?

b. How many unique threads are created?

回答：

a:6个进程：P父进程，pid = fork()创建的子进程P1，if语句中fork()创建的P2，以及P，P1和P2在最后一个fork()中分别创建的P3，P4和P5——共**6****个**进程，不算父进程的话，**unique processes****有****5****个**

b：线程创建是在if中完成的。if块中执行独子进程P1。因此，进程P1将被创建一个线程。进程P2使用fork()创建。因此，进程P2也将创建一个线程。因此，将创建**2****个****unique**线程。

**4.17**

题目：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?

回答：

**LINE C****值＝5****。**

线程中的子进程由父进程fork，子进程每个都有自己的内存空间。

在fork之后，父进程等待子进程的完成。

为子进程创建新线程，调用Runnor（）函数，将全局ValLable的值设置为5。

因此，在执行此行之后，所显示的值将为5。

**LINE P****值＝0****。**

在完成子进程之后，父进程中存在的全局变量的值仍然为0。

因此，在执行此行之后，所显示的值将为0。

**4.21**

题目：Write a multithreaded program that calculates various statistical values for a list of numbers. This program will be passed a series of numbers on the command line and will then create three separate worker threads.

One thread will determine the average of the numbers,

the second will determine the maximum value,

and the third will determine the minimum value.

For example, suppose your program is passed the integers

The variables representing the average, minimum, and maximum values will be storedglobally.

The worker threads will set these values, and the parent thread will output the values once the workers have exited. (We could obviously expand this program by creating additional threads that determine other statistical values, such as median and standard deviation.)

回答：

//  main.c

//  操作系统作业第四章4.21

//  Created by zsy on 2018/10/14.

\#include <stdio.h>

\#include <stdlib.h>

\#include <pthread.h>

\#include <errno.h>

\#include <unistd.h>

\#define handle\_error\_en(en, msg) \\

do \{ errno = en; perror(msg); exit(EXIT\_FAILURE); \} while (0)

/\* 正在运行的线程数\*/

volatileintrunning\_threads = 0;

pthread\_tthread\[3\]; /\*3个线程\*/

intnumOfElements;/\*用户的元素总个数\*/

structResults\{ /\*保存统计结果\*/

intmin;

intmax;

intaverage;

\}Results;

/\*此函数查找数组的最小元素\*/

void\*findMin(void\*array\_ptr)\{

inti;

int\*elements = (int\*)array\_ptr;

Results.min= elements\[0\]; /\*把最小值设置为第一个元素\*/

for(i = 0; i < numOfElements; i++)\{   /\*便利一遍\*/

if(elements\[i\] < Results.min)\{   /\*小于最小值？？\*/

Results.min= elements\[i\];    /\*更新\*/

running\_threads\-= 1;    /\*减少一个线程数\*/

returnNULL;

/\*找最大y\*/

void\*findMax(void\*array\_ptr)\{

inti;

int\*elements = (int\*)array\_ptr;

for(i = 0; i < numOfElements; i++)\{

if(elements\[i\] > Results.max)\{

Results.max= elements\[i\];

running\_threads\-= 1;

returnNULL;

/\*找平均\*/

void\*findAverage(void\*array\_ptr)\{

inti;

int\*elements = (int\*)array\_ptr;

for(i = 0; i < numOfElements; i++)\{

Results.average\+= elements\[i\];

Results.average= Results.average/numOfElements;    /\*除\*/

running\_threads\-= 1;    /\*线程减一\*/

returnNULL;

intgetArrayInput(intn, int\*array\_ptr)\{

intinput;

intnumberOfElements = 0;

printf("创建动态数组y...\\n-\\n");

for(;;)\{  /\*循环\*/

printf("输入一个正数:\\n当输入负数的时候就自动停止啦\\n-\\n");

if(scanf("%d",&input) != 1)\{

printf("\\n这个不是整数啊！！\\n重写！\\n要整数！\\n");

exit(EXIT\_FAILURE);

if(input >= 0)\{

if(numberOfElements == n)\{

n += 1; //为当前输入腾出空间

array\_ptr = realloc(array\_ptr, n \* sizeof(int));

array\_ptr\[numberOfElements++\] = input;

\} else\{

printf("\\n整数一共有: %d\\n", numberOfElements);

break;

returnnumberOfElements;

/\*线程\*/

voidjoinThreads(intnumberOfThreads)\{

ints;

while(numberOfThreads >= 0)\{    /\*加到线程\*/

s = pthread\_join(thread\[numberOfThreads\],NULL);

/\*加入错误\*/

if(s != 0)\{

/\*处理错误\*/

handle\_error\_en(s, "pthread\_create");

numberOfThreads--;

voidcreateThreads(int\*array\_ptr)\{

ints;

s = pthread\_create(&thread\[0\], NULL, findMin, (void\*)array\_ptr);

if(s != 0)\{

handle\_error\_en(s, "pthread\_create");

running\_threads\+= 1;

s = pthread\_create(&thread\[1\], NULL, findMax, (void\*)array\_ptr);

if(s != 0)\{

handle\_error\_en(s, "pthread\_create");

running\_threads\+= 1;

s = pthread\_create(&thread\[2\], NULL, findAverage, (void\*)array\_ptr);

if(s != 0)\{

handle\_error\_en(s, "pthread\_create");

running\_threads\+= 1;

/\* 主函数初始化动态数组并为其分配空间，然后使用pthread\_create创建3线程1来计算min、max和平均值。然后，等待每个线程完成任务，然后加入3个线程，并向用户提示结果。\*/

intmain()\{

intn = 1;

int\*array\_ptr =malloc(n \* sizeof(int));

/\*从用户获取n个大小的元素数组并保存计数\*/

numOfElements= getArrayInput(n, array\_ptr);

createThreads(array\_ptr);

while(running\_threads>0)\{    /\*等待每个线程递减\*/

sleep(1);

joinThreads(2);    /\*调用我们的线程加入函数传递线程数\*/

/\*提示用户\*/

printf("\\nThe average is %d\\nThe maximum is %d\\nThe minimum is %d\\n",Results.average, Results.max, Results.min);

return(0);

**4.22**

题目：An interesting way of calculating is to use a technique known as Monte Carlo, which involves randomization. This technique works as follows: Suppose you have a circle inscribed within a square, as shown in Figure

回答：

操作系统第四章4.22.c：蒙特卡洛c文件。

操作系统第四章4.22：pthreads.c的编译文件。

备注：该程序将根据用户输入生成一系列随机点，这些点以（x，y）坐标表示，它们落在一个正方形的笛卡尔坐标中（其中有一个圆圈）。根据圈中有多少面积而生成π。

启动程序：命令行《./操作系统第四章4.22》或直接xcode运行程序，然后在出现提示时输入所需的点数。

程序在完成计算后立即响应其近似值的结果。

测试样例为30000

//  main.c

//  操作系统第四章4.22

//  Created by zsy on 2018/10/14.

/\* 使用蒙特卡罗方法计算π \*/

\#include <stdio.h>

\#include <string.h>

\#include <pthread.h>

\#include <math.h>

\#include <stdlib.h>

inti         = 0;

intamtWanted = 0;

inttotalPts  = 0;

void\*count(void\*X)

/\* 初始化\*/

for(i=0; i< amtWanted; i\++)

doubleX = (double)rand() / RAND\_MAX;

doubleY = (double)rand() / RAND\_MAX;

if(((X \* X) + (Y \* Y)) <= 1)

totalPts\++;

returnNULL;

intmain()

printf("\\n\\nWelcome to Threaded Monte Carlo, by ZSY\\n\\n");

srand(time(NULL));

pthread\_tthread;

printf("要生成多少个点? \\n");

scanf("%d", &amtWanted);

\}while(amtWanted<= 0);

pthread\_create(&thread,NULL, &count, NULL);

pthread\_join(thread, NULL);

doublepoints = 4.0 \* totalPts;

doublepi = points / amtWanted;

printf("π近似值为(%d) is: %f \\n", amtWanted, pi);

return0;

**附加：实现一个简单网络聊天程序，用到****socket****和****pthread****（接受和发送在****pthread****创建的线程中）**

server

\#include <stdio.h>

\#include <stdlib.h>

\#include <string.h>

\#include <sys/types.h>

\#include <sys/socket.h>

\#include <unistd.h>

\#include <arpa/inet.h>

\#include <netinet/in.h>

\#include <strings.h>

\#include <errno.h>

\#include <pthread.h>

\#define PORT            8003

\#define BACKLOG     10

\#define BUF\_LEN     128

void\*recv\_data(void\*fd);

intmain(intargc, char\*\*argv)

int      sockfd;

int      \*conn\_fd;

struct   sockaddr\_in addr;

if(-1==(sockfd=socket(AF\_INET,SOCK\_STREAM,0)))

perror("socket");

exit(1);

addr.sin\_family = AF\_INET;

addr.sin\_port = htons(PORT);

addr.sin\_addr.s\_addr = htons(INADDR\_ANY);

bzero(&(addr.sin\_zero),8);

if(-1==(bind(sockfd,(structsockaddr\*)&addr,sizeof(addr))))

perror("bind");

exit(1);

if(-1==listen(sockfd, BACKLOG))

perror("listen");

exit(1);

while(1)

pthread\_t thread;

conn\_fd = (int\*)malloc(sizeof(int));

if(-1 == (\*conn\_fd = accept(sockfd, NULL, NULL)))

perror("accept");

continue;

if(0!= pthread\_create(&thread,NULL,recv\_data,conn\_fd))

perror("pthread\_create");

break;

shutdown(sockfd,2);

shutdown(\*conn\_fd,2);

return0;

void\*recv\_data(void\*fd)

int               conn\_fd;

int               recv\_len;

unsignedchar     recv\_buf\[BUF\_LEN\];

conn\_fd = \*((int\*)fd);

for(;;)

memset(recv\_buf,0,BUF\_LEN);

recv\_len = recv(conn\_fd,recv\_buf,BUF\_LEN,0);

if(-1==recv\_len)

perror("recv");

exit(1);

recv\_buf\[recv\_len\] = '\\0';

if(strncmp(recv\_buf,"exit",4)==0)

printf("%s\\n",recv\_buf);

break;

printf("Receive data:%s\\n", recv\_buf);

free(fd);

close(conn\_fd);

pthread\_exit(NULL);

user

\#include <stdio.h>

\#include <sys/types.h>

\#include <sys/socket.h>

\#include <arpa/inet.h>

\#include <netinet/in.h>

\#include <strings.h>

\#include <stdlib.h>

\#include <unistd.h>

\#include <string.h>

\#include <fcntl.h>

\#include <sys/stat.h>

\#include <time.h>

\#define PORT             8003

\#define BUF\_LEN          100

intmain(intargc, char\*argv\[\])

int                    sockfd;

unsignedchar         send\_buf\[BUF\_LEN\];

unsignedchar          send\_len;

structsockaddr\_in     serv\_addr;

if(argc != 2)

printf("Usage: %s ServerIP\\n",argv\[0\]);

exit(1);

bzero(&serv\_addr,sizeof(serv\_addr));

serv\_addr.sin\_family = AF\_INET;

serv\_addr.sin\_port   = htons(PORT);

if((inet\_pton(AF\_INET,argv\[1\],&serv\_addr.sin\_addr)) < 0)

perror("inet\_pton");

exit(1);

if(-1 == (sockfd = socket(AF\_INET, SOCK\_STREAM, 0)))

perror("socket");

exit(1);

if(-1 == connect(sockfd, (structsockaddr \*)&serv\_addr, sizeof(serv\_addr)))

perror("connect");

exit(1);

for(;;)

memset(send\_buf,0,BUF\_LEN);

printf("Input your data:\\n");

fgets(send\_buf,BUF\_LEN,stdin);

fflush(stdin);

if(strncmp(send\_buf,"exit",4)==0)

if(-1 == (send(sockfd, send\_buf, BUF\_LEN,0)))

perror("read");

exit(1);

break;

if(-1 == (send(sockfd, send\_buf, BUF\_LEN,0)))

perror("read");

exit(1);

close(sockfd);

return0;

操作系统作业4

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关【操作系统】作业调度（高级调度）

相关操作系统作业 - 进程调度

相关操作系统作业9

相关操作系统作业8

相关操作系统作业6

相关操作系统作业5

相关操作系统作业4

相关操作系统作业3

相关操作系统作业2

相关操作系统作业1