精华内容
下载资源
问答
  • linux多线程实验报告.pdf
  • java多线程实验报告.pdf
  • 原创的嵌入式多线程实验报告原创,情歌问大佬多多发表意见,新人初到,以后的博客会越来越有技术含量,文件会越来越有帮助
  • 线程实验报告.docx

    2021-09-07 23:29:33
    编写一多线程程序,实现如下功能: (1)一个线程进行阶乘和的运算(1!+2!+3!……+30!), 每次阶乘计算时间随机间隔0.5-1秒; (2)另一个线程每隔1秒时间读取上个线程的运算结果和计算 进程,并在图形界面中...
  • java多线程实验报告

    2020-11-07 10:06:39
    1. 应用图形用户接口和多线程的知识,编写一个应用程序实现下述功能:当单击“开始”按钮时随机产生一个两位整数不断在文本框上显示(每隔300毫秒显示一次),当单击“停止”按钮时,停止显示并将当前产生的数显示在...
  • gSoap 多线程实验报告一、开发环境(客户端、服务器端均相同) 硬件环境:AMD 3200+ 2.0G + 512M DDR + 10/100M 以太网卡 软件环境:Operating System:Windows XP sp2Compiler: Visual C++ 6.0SOAP SDK: gSoap ...
      
    
    gSoap 多线程实验报告
    一、开发环境(客户端、服务器端均相同)
     
    硬件环境:
    AMD 3200+ 2.0G + 512M DDR + 10/100M 以太网卡
     
    软件环境:
    Operating System:Windows XP sp2
    Compiler: Visual C++ 6.0
    SOAP SDK: gSoap 2.7.9c
    Multithread Library: pthread-2.5.0-win32-release
    SSL Library: OpenSSL 0.9.7m
     
    二、gSoap多线程程序的编写
    2.1 服务器端程序的编写
     
    对于服务器端,首先调用 soap_ssl_server_contex完成 SSL上下文环境的初始化,然后等待客户端发出服务请求。当主线程中检测到客户端发出新的SOAP请求时,调用 struct  soap *soap_copy(struct soap *soap) 函数创建新的soap 运行时环境(Runtime enviroment),新创建的 soap 与原先的soap runtime enviroment 是相互独立的,因此在多线程环境中各个线程可以独立处理 SOAP 请求而互不干涉。要在gSoap的服务器端支持OpenSSL,必须在调用 soap_accept后继续调用 soap_ssl_accept函数。在 soap_ssl_accept 验证后服务器和客户端建立安全的 SSL通道,然后主线程调用 pthread_create 创建新的线程来完成 SOAP服务。一个基本的服务器框架如下所示。
    注意: 要在多线程的环境中使用 OpenSSL ,必须使用到这两个例程 CRYPTO_thread_setup() CRYPTO_thread_cleanup() 附录中给出了在 Win32 POSIX 的这两个例程的实现代码。
     
    int  main()
    {
       int m, s;
       pthread_t tid;
       struct soap soap, *tsoap;
       soap_ssl_init(); /* init OpenSSL (just once) */
    /* Note: CRYPTO_thread_setup() must be called in multi-thread environment */
       if (CRYPTO_thread_setup())
       {
          fprintf(stderr, "Cannot setup thread mutex/n");
          exit(1);
       }
       soap_init(&soap);
       if (soap_ssl_server_context(&soap,
          SOAP_SSL_DEFAULT,
          "server.pem", /* keyfile: required when server must authenticate to clients (see SSL docs on how to obtain this file) */
          "password", /* password to read the key file */
          "cacert.pem", /* optional cacert file to store trusted certificates */
          NULL, /* optional capath to directory with trusted certificates */
          "dh512.pem", /* DH file, if NULL use RSA */
          NULL, /* if randfile!=NULL: use a file with random data to seed randomness */
          NULL /* optional server identification to enable SSL session cache (must be a unique name) */    ))
       {
          soap_print_fault(&soap, stderr);
          exit(1);
       }
       m = soap_bind(&soap, NULL, 18000, 100); // use port 18000
       if (m < 0)
       {
          soap_print_fault(&soap, stderr);
          exit(1);
       }
       fprintf(stderr, "Socket connection successful: master socket = %d
    / n", m);
       for (;;)
       {
          s = soap_accept(&soap);
          fprintf(stderr, "Socket connection successful: slave socket = %d
    / n", s);
          if (s < 0)
          {
             soap_print_fault(&soap, stderr);
             break;
          }
          tsoap = soap_copy(&soap); /* should call soap_ssl_accept on a copy */
          if (!tsoap)
             break;
          if (soap_ssl_accept(tsoap))
          {
             soap_print_fault(tsoap, stderr);
             soap_free(tsoap);
             continue; /* when soap_ssl_accept fails, we should just go on */
          }
          pthread_create(&tid, NULL, &process_request, (void*)tsoap);
       }
       soap_done(&soap); /* deallocates SSL context */
       CRYPTO_thread_cleanup();
       return 0;
    }
    void *process_request(void *soap)
    {
       pthread_detach(pthread_self());
       soap_serve((struct soap*)soap);
       soap_destroy((struct soap*)soap);
       soap_end((struct soap*)soap);
       soap_done((struct soap*)soap);
       free(soap);
       return NULL;
    }
     
    2.2 客户端程序的编写
    客户端中,使用 #define MAX_THREAD 来定义最大的线程数。主线程使用 pthread_create()创建 MAX_THREAD个线程。新线程创建后,调用 soap_ssl_client_context初始化 SSL上下文环境。SSL 验证通过后,服务器端和客户端线程之间建立SSL通道,之后客户端发出SOAP服务请求。多线程的客户端程序框架如下所示。
    同样地,为了在多线程环境中使用使用OpenSSL, 必须使用到这两个例程 CRYPTO_thread_setup() CRYPTO_thread_cleanup()
     
    int main(void)
    {
           int i=0;
           for(i=0; i<MAX_THREAD; i++)
           {
                  /* create the threads to send the SOAP request */
                  THREAD_CREATE(tid[i],(void(*)(void*))test,NULL);
           }
    /* stay forever for the sub-threads to execute */
           while (1)
           {
                  /* Do something here. */
           }
           return 0;
    }
    void test()
    {
    struct soap soap;
    struct _ns1__Query q;
    struct _ns1__QueryResponse response;
     
    struct _ns1__Pay p;
    struct _ns1__PayResponse p_res;
     
    /* Init OpenSSL */
     
    soap_ssl_init();
     
    /* Note: CRYPTO_thread_setup() must be called in multi-thread environment */
    if (CRYPTO_thread_setup())
    { fprintf(stderr, "Cannot setup thread mutex/n");
    exit(1);
    }
     
    if (soap_ssl_client_context(&soap,
        SOAP_SSL_REQUIRE_SERVER_AUTHENTICATION|SOAP_SSL_SKIP_HOST_CHECK|SOAP_SSL_REQUIRE_CLIENT_AUTHENTICATION ,//| SOAP_SSL_SKIP_HOST_CHECK, /* use SOAP_SSL_DEFAULT in production code, we don't want the host name checks since these will change from machine to machine */
        "client2003.pem",//NULL,               /* keyfile: required only when client must authenticate to server (see SSL docs on how to obtain this file) */
        "crusader",//NULL,            /* password to read the keyfile */
        "ca2003.pem",       /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */
        NULL,        /* optional capath to directory with trusted certificates */
        NULL          /* if randfile!=NULL: use a file with random data to seed randomness */
           ))
    { soap_print_fault(&soap, stderr);
    exit(1);
    }
     
    while(1)
    {
     
           /* the thread must stop for a while. Will be explaned later */
           Sleep(1000);
           q.UserID =”test”;;
           q.Pasword = "test";
           q.QueryType = 100;
    /* send the SOAP request to query */
           if (soap_call___ns1__query(&soap,server,"",&q,&response)==SOAP_OK)
           {
           printf("Status=%d,Amount=%d,SerialNO=%d/n",response.Status,response.Amount,response.SerialNO);
           }
           else
           {
                  soap_print_fault(&soap, stderr);
           }
          
      
           srand((int)time(NULL));
           p.Amount = rand()%10000+300;   
           p.Password =”password”;
           p.PayType = rand()%4;
           p.Description =”descrpition”;
           p.UserID = names[rand()%4];
    /* send the request to pay */
           if (soap_call___ns1__pay(&soap,server,"",&p,&p_res)==SOAP_OK)
           {
           printf("Status=%d,Amount=%d,SerialNO=%d/n",p_res.Status,p_res.Amount,p_res.SerialNO);
           }
           else
           {
                  soap_print_fault(&soap, stderr);
           }
    }
     
    soap_destroy(&soap); /* C++ */
    soap_end(&soap);
    soap_done(&soap);
    CRYPTO_thread_cleanup();
    }
     
    三、实验结果及分析
    实验中我们发现:虽然我们可以在客户端中开启大量的线程(如设置最大线程数MAX_THREAD=200),但我们如果使用netstat命令来观察socket连接时可以看到:实际上同一时刻只有部分线程的socket 的状态是 ESTABLISHED(已连接),其他的socket处于TIME_WAIT状态。查阅资料后总结原因:服务器的一个端口监听多个socket 连接的 soap_bind(struct soap *soap, char *host, int port, int backlog) 函数中的backlog指定了请求的队列大小。backlog的值受到系统的限制(在Linux下默认为128,在Windows下,根据MSDN 的内容,没有确定值)。当同一时刻有大量的线程发送请求时,队列过小无法处理所有的请求,部分线程要等待服务器处理完原有的队列后才能得到服务。如:在MAX_THREAD=300的情况下,某一时刻,真正接受服务的线程只有 125 个。 同时我们在实验中也可以看到,在 MAX_THREAD=300 的情况下,所有的线程都能够得到服务,但各个线程得到的服务的次数有些差别,如:某一时刻,得到最多服务次数的线程完成服务次数为 399 次,而得到最少服务次数的线程完成服务次数为 364 次。
    实验中我们还发现,在gSoap完成请求并断开socket之后,原有的socket并不能立即被重用,必须等待一定的时间(该值可以在注册表中设置:HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters/ TcpTimedWaitDelay。 取值范围为30-240s)在客户端开启线程较多的情况下,socket没有立即回收导致socket资源很快就耗竭的问题。我们通过在客户端程序中的每次SOAP请求之后调用Sleep(1000),降低请求频率来解决这个问题。
     
     
     
     
     
     
     
     
     
    四、附录
    CRYPTO_thread_setup()CRYPTO_thread_cleanup() 的实现代码。
    #include < unistd.h > /* defines _POSIX_THREADS if pthreads are available */
    #ifdef _POSIX_THREADS
    # include < pthread.h >
    #endif
    #if defined(WIN32)
    # define MUTEX_TYPE HANDLE
    # define MUTEX_SETUP(x) (x) = CreateMutex(NULL, FALSE, NULL)
    # define MUTEX_CLEANUP(x) CloseHandle(x)
    # define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
    # define MUTEX_UNLOCK(x) ReleaseMutex(x)
    # define THREAD_ID GetCurrentThreadID()
    #elif defined(_POSIX_THREADS)
    # define MUTEX_TYPE pthread_mutex_t
    # define MUTEX_SETUP(x) pthread_mutex_init(&(x), NULL)
    # define MUTEX_CLEANUP(x) pthread_mutex_destroy(&(x))
    # define MUTEX_LOCK(x) pthread_mutex_lock(&(x))
    # define MUTEX_UNLOCK(x) pthread_mutex_unlock(&(x))
    # define THREAD_ID pthread_self()
    #else
    # error "You must define mutex operations appropriate for your platform"
    # error "See OpenSSL /threads/th-lock.c on how to implement mutex on your platform"
    #endif
    struct CRYPTO_dynlock_value { MUTEX_TYPE mutex; };
    static MUTEX_TYPE *mutex_buf;
    static struct CRYPTO_dynlock_value *dyn_create_function(const char *file, int line)
    {
       struct CRYPTO_dynlock_value *value;
       value = (struct CRYPTO_dynlock_value*)malloc(sizeof(struct CRYPTO_dynlock_value));
       if (value)
          MUTEX_SETUP(value
    -> mutex);
       return value;
    }
    static void dyn_lock_function(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line)
    {
       if (mode & CRYPTO_LOCK)
          MUTEX_LOCK(l
    -> mutex);
       else
          MUTEX_UNLOCK(l
    -> mutex);
    }
    static void dyn_destroy_function(struct CRYPTO_dynlock_value *l, const char *file, int line)
    {
       MUTEX_CLEANUP(l
    - >mutex);
       free(l);
    }
    void locking_function(int mode, int n, const char *file, int line)
    {
       if (mode & CRYPTO_LOCK)
          MUTEX_LOCK(mutex_buf[n]);
       else
          MUTEX_UNLOCK(mutex_buf[n]);
    }
    unsigned long id_function()
    {
       return (unsigned long)THREAD_ID;
    }
    int CRYPTO_thread_setup()
    {
       int i;
       mutex_buf = (MUTEX_TYPE*)malloc(CRYPTO_num_locks() * sizeof(MUTEX_TYPE));
       if (!mutex_buf)
          return SOAP_EOM;
       for (i = 0; i < CRYPTO_num_locks(); i++)
          MUTEX_SETUP(mutex_buf[i]);
       CRYPTO_set_id_callback(id_function);
       CRYPTO_set_locking_callback(locking_function);
       CRYPTO_set_dynlock_create_callback(dyn_create_function);
       CRYPTO_set_dynlock_lock_callback(dyn_lock_function);
       CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);
       return SOAP_OK;
    }
    void CRYPTO_thread_cleanup()
    {
       int i;
       if (!mutex_buf)
          return;
       CRYPTO_set_id_callback(NULL);
       CRYPTO_set_locking_callback(NULL);
       CRYPTO_set_dynlock_create_callback(NULL);
       CRYPTO_set_dynlock_lock_callback(NULL);
       CRYPTO_set_dynlock_destroy_callback(NULL);
       for (i = 0; i < CRYPTO_num_locks(); i++)
          MUTEX_CLEANUP(mutex_buf[i]);
       free(mutex_buf);
       mutex_buf = NULL;
    }
     
    欢迎光临我的blog: http://www.info-life.cn
     
    展开全文
  • 一个简单的操作系统实验报告,很简单,。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 实现一个CD出租销售店的模拟程序销售线程,销售线程可以有两个或两个以上,启动的时间为200ms。购买数量为5以内的随机数。如果cd数量不足则随机选择等候或放弃。包括实现源代码以及输出record.txt
  • JAVA多线程实验报告

    2008-12-10 13:58:10
    利用多线程技术编写applet程序。其中包含一个滚动的字符串,字符串从左向右移动,当所有的字符都从屏幕的右边消失后,字符串重新从左边出现并继续向右移动
  • 死锁,进程和线程实验报告,都是在red hat 9下实际运行过可行的代码,这份是完成以后写的实验报告,里面还有截图
  • 创建四个线程A、B、C、D及消息队列,A线程往消息队列里写入1~99,B线程入消息队列里写入a~z,C线程从消息队列里读取A线程写入的数据显示在屏幕上,D线程读取B线程写入消息队列里的数据写入当前文档的文件中。
  • Linux系统线程死锁实验报告.pdf
  • 本文件为操作系统中的线程同步实验的实验报告,有详细的代码和解释。
  • 本文档系操作系统课程线程同步机制的实验报告,实验内容包括:无同步机制、调用Mutex互斥变量、使用peterson软件法实现线程同步。完整的cpp源代码见文档附录。
  • 线程并发拷贝程序实验报告及实验结果
  • 操作系统实验Nachos线程审计实验代码及实验报告
  • 操作系统线程同步机制实验报告.pdf
  • applet线程动画实验实验报告

    千次阅读 2009-01-12 16:47:00
    2、 完成实验报告的写作,并通过本机房网络提交,或课后email提交(cylincylin@163.com)二、 实验要求1、熟悉桌面上的“第七章”课件2、在此基础上,自行设计一个动画片或其他线程应用程序3、完成实验报告写作,...
      
    

    第一次写applet = = ……


    实验项目:applet线程动画实验

    一、 实验内容

    1、 自行设计一个动画片或其他线程应用程序。
    2、 完成实验报告的写作,并通过本机房网络提交,或课后email提交(cylincylin@163.com)

    二、 实验要求

    1、熟悉桌面上的“第七章”课件
    2、在此基础上,自行设计一个动画片或其他线程应用程序
    3、完成实验报告写作,课程结束前上交。

    三、 实验目的

    1、理解并掌握applet的设计。
    2、理解并掌握Thread的设计。
    3、理解并掌握Graphics的使用。
    4、进一步学习JAVA的编程思想。

    四、 实验条件

    编译器: Jcreator
    Java环境: JDK 6.0
    操作系统: Windows XP SP2

    五、思路分析

    1、 要播放动画必须新建一个该动画的线程,实现它的paint()方法,描述各个时期应该重绘的内容,启动该线程即开始播放动画;
    2、 要控制圆放大缩小,就要定义它的最大、最小半径,以及当前变化状态(放大、缩小);
    3、 已知圆心坐标(x,y),半径r,可得圆的左上角坐标为(x-r/2,y-r/2);
    4、 为使动画加快或放慢速度,可适当调节线程run方法中repaint后的线程休眠时间。为更好地体现动画效果,这里设置为80ms;
    5、 为在实心圆外绘制多个圆框延续到最大半径,用一个循环绘制,每个间距离为10。

    六、 程序代码

    【ThreadApplet.java】

    1. import java.applet.*;
    2. import java.awt.*;
    3.  
    4. /**
    5. * applet线程动画实验
    6. * @author Cyin
    7. * @author Lee
    8. * @author Komi
    9. * @author Skittles
    10. * @since 2009-1-2
    11. * @version 1.0
    12. */
    13. public class ThreadApplet extends Applet implements Runnable {
    14.  
    15.         /**
    16.          * 圆心x坐标
    17.          */
    18.         private int x = 0;
    19.        
    20.         /**
    21.          * 圆心y坐标
    22.          */
    23.         private int y = 0;
    24.        
    25.         /**
    26.          * 圆当前半径
    27.          */
    28.         private int r = 0;
    29.        
    30.         /**
    31.          * 圆最小半径
    32.          */
    33.         private int minR = 0;
    34.        
    35.         /**
    36.          * 圆最大半径
    37.          */
    38.         private int maxR = 0;
    39.        
    40.         /**
    41.          * 圆的颜色
    42.          */
    43.         private Color color = Color. black;
    44.        
    45.         /**
    46.          * 圆当前变化的方向:true为放大,false为缩小
    47.          */
    48.         private boolean direction = true;
    49.        
    50.         /**
    51.          * 设定圆的信息
    52.          * @param x 圆心x坐标
    53.          * @param y 圆心y坐标
    54.          * @param r 圆初始半径
    55.          * @param minR 圆最小半径
    56.          * @param maxR 圆最大半径
    57.          * @param rgb 圆的颜色代码(十六进制的六位数)
    58.          * @param direction 圆变化的初始方向
    59.          */
    60.         public void setRoundRect ( int x, int y, int r,
    61.                         int minR, int maxR, int rgb, boolean direction ) {
    62.                 this. x = x;
    63.                 this. y = y;          
    64.                 this. r = r;
    65.  
    66.                 this. minR = minR;
    67.                 this. maxR = maxR;
    68.                
    69.                 this. color = new Color (rgb );
    70.                 this. direction = direction;
    71.         }
    72.        
    73.         /**
    74.          * 构造器:
    75.          */
    76.         public ThreadApplet ( ) {
    77.                 //      设定画布颜色
    78.                 this. setBackground ( Color. GRAY );
    79.                
    80.                 //      设定画布大小
    81.                 this. setSize ( 300, 200 );
    82.                
    83.                 // 设定圆信息
    84.                 this. setRoundRect ( 150, 100, 50, 30, 150,0x0, true );
    85.                
    86.                 // 创建线程并启动
    87.                 new Thread ( this ). start ( );              
    88.         }
    89.        
    90.         /**
    91.          * 线程内容
    92.          */
    93.         public void run ( ) {
    94.                 while ( true ) {
    95.                         try {
    96.                                 //      重绘画布
    97.                        repaint ( );
    98.                        
    99.                         // 每次休眠80ms
    100.                                 Thread. sleep ( 80 );
    101.                         }
    102.                         catch ( Exception e ) {
    103.                         }
    104.               }
    105.          }
    106.        
    107.         /**
    108.          * 绘制画布内容
    109.          */
    110.         public void paint ( Graphics g ) {
    111.                 if (direction ) {
    112.                         //      当方向为true(表圆正在放大)时
    113.                         //      半径增加
    114.                         r++;
    115.                        
    116.                         //      当半径达到最大半径时
    117.                         if (r==maxR ) {
    118.                                 //      改为缩小
    119.                                 direction = false;
    120.                         }
    121.                 }
    122.                 else {
    123.                         //      当方向为false(表圆正在缩小)时
    124.                         //      半径减少
    125.                         r--;
    126.                        
    127.                         //      当半径为最小半径时
    128.                         if (r==minR ) {
    129.                                 //      改为放大
    130.                                 direction = true;
    131.                         }
    132.                 }
    133.  
    134.                 //      设置画笔颜色
    135.                 g. setColor (color );
    136.                 //      填充一个圆心为(x,y)、半径为r的圆
    137.                 g. fillRoundRect (x - r/ 2, y - r/ 2, r, r, 360, 360 );
    138.                
    139.                 //      绘制圆圈,使延续到最大半径
    140.                 for ( int i= 1, t = 10; i <= (maxR-r )/ 10 +1 ;i++ ) {
    141.                         //      绘制一个圆心在(x,y)、半径为r+10*i的圆(线框)
    142.                         g. drawRoundRect (x - r/ 2 - t*i/ 2, y - r/ 2 - t*i/ 2, r + t*i, r + t*i, 360, 360 );
    143.                 }
    144.         }
    145.  
    146. }

     

    运行后生成ThreadApplet.class文件,在相同目录下新建一个html文件,内容为:

    1. <head> <title>applet线程动画实验 </title> </head>
    2. <applet width="300" height="200" code="ThreadApplet.class"> </applet>
    3. </body>
    4. </html>
    5.  

     

    七、 调试与运行情况

    八、 实验小结

    1、理解并掌握了applet的设计。
    2、理解并掌握了Thread的设计。
    3、理解并掌握了Graphics的使用。
    4、进一步学习了JAVA的编程思想。

    展开全文
  • Nachos 4.1 lab1 线程机制实验报告 目录 内容一:总体概述 3 内容二:任务完成情况 3 任务完成列表(Y/N) 3 具体Exercise的完成情况 3 内容三:遇到的困难以及解决方法 4 内容四:收获及感想 5 内容五:对课程的...

    Nachos 4.1 lab1 线程机制实验报告

    目录
    内容一:总体概述 3
    内容二:任务完成情况 3
    任务完成列表(Y/N) 3
    具体Exercise的完成情况 3
    内容三:遇到的困难以及解决方法 4
    内容四:收获及感想 5
    内容五:对课程的意见和建议 5
    内容六:参考文献 5

    内容一:总体概述
    线程是操作系统CPU调度最基本的单位,每个线程都有自己唯一的线程编号TID,记录线程信息的数据结构为TCB。在线程创建时,也需要为线程分配内存空间。线程也有创建后的初始就绪态,占用CPU的运行态和退出后的销毁态。
    在nachos中有一个核心的内核级线程main,是操作系统内核初始化时第一个建立的线程,可以利用它来fork创建其余线程。也可以直接new Thread线程构造函数建立新的线程。但nachos中没有实现父子线程的继承关系。

    内容二:任务完成情况
    任务完成列表(Y/N)
    Exercise 1 调研(Y)
    Exercise 2 源代码阅读(Y)
    Exercise 3 扩展线程的数据结构(Y)
    Exercise 4 增加全局线程管理机制(Y)

    具体Exercise的完成情况
    第一部分
    Exercise1 基础知识
    Linux中进程控制块(PCB)叫做task_struct,主要包含标识符pid:用于唯一标识进程,区别于其他进程,同时还有进程组标识;状态state:任务状态,退出代码,中断信号等;实时优先级:用于计算实时进程调度时的weight值;程序计数器:程序中即将被执行的下一条指令的地址;内存指针:存放进程内存管理信息,包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针;上下文环境:进程执行时处理器的寄存器中的数据;I/O状态信息:包括显示的I/O请求,分配给进程的I/O设备和被进程打开的文件列表;记录信息:可能包括处理器时间总和,使用的时钟总和,定时器终止时间,记账号等。
    Linux的进程状态可分为运行态,可中断和不可中断态,暂停态,终止态,僵尸状态,挂起状态等。
    在nachos系统,PCB在thread.h中实现。包括stackTop:当前栈指针;machineState未在CPU上所有寄存器的状态;fork等函数头的定义;私有属性:stack栈底指针,status进程的状态,name进程名。
    主要区别在于linux中PCB包含的信息更多,nachos中仅包含了必须的信息,并且nachos中没有限制线程的总数量。Nachos的线程机制没有实现父子线程的继承关系,只有核心线程fork产生其余线程。

    Exercise2 源码阅读
    Mian.cc文件:Kernel类,记录内核信息,包括当前占用cpu的线程和线程就绪队列;Copy函数,复制文件内容,如果打开失败则返回;Print函数将name文件的内容输出,利用一个设定长度的buffer多次获取数据并输出;main函数,进行变量的初始化,解析argc和argv中的命令,判断要执行的指令,调用不同的函数。并建立内核状态。
    threadtest.cc文件:线程测试方法,在nachos4.1并将此功能并入了main.cc文件中。
    thread.h文件
    主要对于线程的定义。内存栈空间的大小8*1024,线程状态(创建、运行、就绪、阻塞),在Thread类中定义线程的数据结构,包括栈指针,未在CPU上的所有寄存器的状态,线程主要函数的预定义;stack线程栈底指针,线程名,用户寄存器的状态等。
    thread.cc文件
    线程fork、begin、finish、yield和sleep功能的实现。
    Thread构造函数:传入线程名并初始化线程;~Thread析构函数:删除线程,assert断言表示判断布尔表达式,判断当前线程是否在运行,只有不在运行状态中的线程才能被删除;
    fork函数:func参数为新线程运行的函数,函数首先复制内核线程的中断帧和进程队列,其次开辟线程内存空间,关闭中断状态准备运行当前线程最后恢复中断状态。
    Checkoverflow函数:检查线程的内存空间是否溢出
    Begin函数:将可运行的线程开始运行, 并允许中断
    Finish函数:将正在运行中的线程睡眠
    Yield函数:线程放弃cpu,并运行下一个线程
    Sleep函数:线程由于某种原因进入阻塞状态等待一个事件的发生,当这些条件得到满足,该线程又可以恢复就绪状态
    Stackallocate函数:为新线程申请栈空间,并设置好准备运行线程的条件。

    Exercise 3、Exercise 4 增加线程数据结构并实现全局线程管理机制
    合并完成Exercise 3和Exercise 4,首先在thread.h中添加userid和threadid两个private的int型变量作为用户ID和线程ID,并添加两个获取对应ID的public函数。
    为限制线程总数,设置一个全局的数组int ThreadIDs[MAXThreads];MAXThreads代表最大线程数,本次设为128。数组初始值均为0,每建立一个线程则将对应的位置赋为1,除主线程main(mainID为1000)外,每个线程的ID即数组中对应的下标。
    对于用户ID,创建的新线程直接利用unistd.h头文件中带有的getuid函数获取当前系统的userid,测试中为1000。
    对于线程ID,修改Thread线程构造函数,添加线程ID分配功能AllocateThreadID:实现的原理是每次利用一个for循环从线程数组中寻找为0位置的下标赋给新线程并设为1然后返回,如果没有找到,说明线程已分配满(对线程数量的限制)返回-1。在Thread构造函数中,ThreadID会接受分配函数的返回值,如果发现值为-1即线程数量已满,则输出“Reached MaxThreadsNum!!”,再利用ASSERT断言限制后续代码的运行,即停止新线程的创建。
    当线程退出时,在~Thread析构函数中,将线程数组中线程ID下标所对应的值重新设为0。
    在这里插入图片描述
    在main.cc主函数文件中,添加对-t命令的解析,即最大线程数量的测试,结果如图。
    在这里插入图片描述

    简单TS功能的实现,直接利用scheduler.cc中的print功能输出readyList就绪队列,并加上正在执行的currentthread。
    /home/stillings/Downloads/nachos
    在这里插入图片描述
    内容三:遇到的困难以及解决方法
    困难1
    不知道nachos是怎么编译的,没有理解Ubuntu与nachos之间的关系。
    解决方法:
    查阅了nachos中文文档和互联网上的相关资料,理解了nachos是运行在软件模拟的虚拟机上的操作系统,可以直接在build.linux中利用make直接编译完成nachos系统并通过./nachos+对应命令执行相应的功能。
    困难2
    一开始拿到代码时,无法理解每个代码文件的作用和文件内各个函数之间的关系,同时不同文件之间,数据和函数的调用经常出错。
    解决方法:
    先在WINDOWS操作系统的编译器中阅读代码,理清代码文件之间的关系,再在ubuntu中编写代码并调试运行。

    内容四:收获及感想
    对大型软件的设计和实现有了更深的体会,学会了C++面向对象的思想巧用构造函数和析构函数实现类的建立和销毁。不同代码文件之间函数的调用,对操作系统线程机制和线程队列以及cpu调度都有了更深的理解。
    内容五:对课程的意见和建议
    课程Nachos实习与XV6源码阅读可以分开安排,没必要同一周内完成。
    内容六:参考文献
    Nachos中文文档

    展开全文
  • 武汉理工大学面对对象课程实验报告,已通过
  • 线程web服务器+部分实验报告线程web服务器+部分实验报告线程web服务器+部分实验报告线程web服务器+部分实验报告 网络课作业
  • 操作系统 课程设计任务书 实验题目 实验一进程与线程Linux 进程与线程通讯 实验目的 深刻理解线程与进程的概念掌握进程与线程在组成成分上的差别以及 与其相适应的通讯方式和应用目标 实验内容 以 Linux 系统进程和...
  • 操作系统实验报告线程的创建和撤销; 基于Windows xp;需要提前安装虚拟机;内含源程序和程序运行结果。
  • 实验报告五多线程.pdf

    2020-11-16 01:39:43
    面向对象程序设计实验报告 实验序号 5 日期 2011 年 6 月 3 日 班 级 姓名 学号 实验项目名称 多线程 学时 指导教师 实验目的 1 掌握线程的 4种状态新建运行中断死亡 2 学习用 Thread类创建线程掌握哪些数据是线程...
  • 这是武汉理工大学面向对象多线程实验实验报告,并在今天验收成功,可以下载下来参考参考
  • windows系统的多线程同步实验报告和cpp文件
  • 线程web服务器 附实验报告 java

    热门讨论 2008-12-12 13:01:23
    线程web服务器源码和实验报告 实现Runnable 接口方法实现
  • 线程java代码和实验报告
  • 成绩 面向对象原理与Java实践课程实验报告 实验5多线程 姓 名 _ _ _ 班 级 _ 学 号 _ 实验地点 _ 实验时间 _ 指导教师 _ _ _ 一实验目的 了解线程调度机制 理解线程同步机制 掌握线程设计方法 二实验要求 掌握线程...
  • 实验报告_Linux线程、互斥.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,668
精华内容 6,667
关键字:

线程实验报告