当前位置： 首页 > wzjs >正文

网站建设典型发言黄页88

wzjs 2025/7/29 11:18:48
网站建设典型发言,黄页88,做的好的响应式网站,微信营销案例分析线程 进程的创建: 1. fork --- 复制 2. vfork 虚拟拷贝 copy on write //写时拷贝 总结: 1.进程创建过程 --- 是通过复制 导致 创建时 ，需要拷贝大量的数据 --- 影响效率 2.线程拷贝 减少了拷贝的数据量 ---提升创建…

线程 


进程的创建:
   1. fork --- 复制
      
   2. vfork 虚拟拷贝 
       copy on write //写时拷贝 
     
总结:
   1.进程创建过程 --- 是通过复制 
     导致 创建时 ，需要拷贝大量的数据 --- 影响效率 
   2.线程拷贝
     减少了拷贝的数据量 ---提升创建效率 
   3.进程 是 CPU 调度的基本单位 
    
 

进程(重量级的进程): 更多侧重于 成为 资源分配的单位    ---- 资源分配的基本单位
线程(轻量级的进程): 更侧重于 成为一个 执行单位            ---- 调度执行的最小单位 
线程组成:
 线程id   //long -- 8字节 
 程序计数器 (program counter) //寄存器  --- 8字节  
 其它寄存器  // 51 * 8 字节 = 408字节
 栈  //8M
 

进程的组成:
     text|data|bss|堆栈| + pcb
   
线程 --- 主要侧重 去 执行任务 (资源更多的是共享了进程资源)

线程 和 进程之间的关系:


  1.线程是依附于进程的 
  2.进程不存在，相关的线程也不复存在 
  3.一个进程中，可以创建多个线程 
  4.进一步提高了并发程度 
  
  
        fork
         |
    /        \
father      child 
 /            \
多个线程      多个线程 

linux下如何进行线程编程:

NPTL 函数库 --- 提供了线程的操作 
                  
New     Posix Thread Library //新的posix标准的线程库 
Native                       //本地线程库 
            

NPTL库 --- stdio 


1.创建 
2.执行
3.结束             


  pthread_create //线程创建 
  


 #include <pthread.h>

      int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                          void *(*start_routine) (void *), void *arg);
      功能:
          创建一个新的线程
      参数:
        @thread --- 线程id 
        @attr   --- 线程属性  //默认属性 NULL --可结合性   
                              //可分离属性 
        @start_routine ---线程执行函数//线程回调函数 --- 提现线程任务执行的部分
        @arg           ---这是传给 start_routine 函数的参数
          
  void * do_something(void *arg)  //线程执行函数
  {
     
  }
     返回值:
        成功   0
        失败  返回错误码 
        
创建出来的线程 --- 次线程 子线程
原先main函数对应执行流 --- 主线程

练习:
    创建两个线程 
    线程1 打印  线程1 ... pid    //getpid
    线程2 打印  线程2 ... pid    //getpid
    
    
    
注:    
    编译
    gcc pthread_creat.c -lpthread
   //链接库     
   
   
           [NPTL 库] <--- tid表示的是在 NPTL库中 对线程的 一个代表
              |           
   -----------|-------------------   getpid
  内核        | 
              |
           do_clone(,SHARED) //线程 --- 进程 
    
    
    
eg:
    定义一个全局变量 
    要求  线程1  做 加 1 
          线程2     加 2
          线程3     加 3

#include<stdio.h>
#include<pthread.h>
#include<errno.h>
#include<unistd.h>
//int num;
void * do_something1(void *arg)
{int *n=(int *)arg;while(1){(*n)+=1;printf("num = %d\n",*n);sleep(2);}return NULL;
}
void * do_something2(void *arg)
{int *n=(int *)arg;while(1){(*n)+=2;printf("num = %d\n",*n);sleep(2);}return NULL;
}
void * do_something3(void *arg)
{int *n=(int *)arg;while(1){(*n)+=3;printf("num = %d\n",*n);sleep(2);}return NULL;
}typedef void *(*thread_cb_t)(void*);
int main(int argc, const char *argv[])
{thread_cb_t func[3]={do_something1,do_something2,do_something3};;pthread_t tid[3];int i=0;int m=0;for(i=0;i<3;i++){int ret;if((ret=pthread_create(&tid[i],NULL,func[i],&m))!=0){errno=ret;perror("pthread_create fail");return -1;}}while(1){printf("--------main------m=%d\n",m);sleep(2);}return 0;
}


          
好处:          
     线程共享数据方便 
      --- 带来 ---竞争问题 
      

线程结束方式：


 The new thread terminates in one of the following ways:

       * It calls pthread_exit(3), 
         specifying an exit status value that is available to another thread 
         in the same process that calls pthread_join(3).

       * It returns from start_routine(). 
           This is equivalent to calling pthread_exit(3) with the value supplied in the return statement.

       * It is canceled (see pthread_cancel(3)).

       * Any of the threads in the process calls exit(3), or the main thread performs a return from main(). 
       This causes the termination of all threads in the process.

pthread_exit 


void pthread_exit(void *retval);
功能:
    结束线程 
参数:
   retval --- 带出的值的 地址 
 
注意:
   pthread_exit //带出的是 保存了 退出状态值  的空间的地址
                //退出状态值 不能放在栈上 
                

int pthread_join(pthread_t thread, void **retval);


int pthread_cancel(pthread_t thread) 


功能：
    取消线程 
参数:
  thread --- 要取消的线程的tid 
返回值 
   成功 0 
   失败 错误码 
   
注意:
  1. 线程间 的地位是平等的 可以相互取消 
  


总结:


 线程:
    1.线程 --- 轻量级的进程 
    2.线程组成 
      线程tid 
      程序计数器 
      其它寄存器 
      栈 
    3.创建线程 
      pthread_create 
         tid 
         属性 -- 可结合 可分离 ---决定最终资源的回收方式  
         线程执行函数 --- 这是体现线程任务的部分 
         arg  -- 传给线程执行函数的参数 
   4.线程退出 
     a.pthread_exit 
     b.return ---线程执行函数中 
     c.pthread_cancel 
     d.exit 
   
   5.线程退出状态值 
     pthread_join 


eg:
     多线程拷贝文件 

#include <stdio.h>
#include <pthread.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>typedef struct
{int fd_s;int fd_d;int size;int len;int id;
}msg_t;
#if 0
void * do_copy (void *arg)
{msg_t *p = arg;lseek(p->fd_s,p->size*p->id,SEEK_SET);lseek(p->fd_d,p->size*p->id,SEEK_SET);printf("tid = %ld id = %d fd_s = %d fd_d = %d size = %d len = %d\n",pthread_self(),p->id,p->fd_s,p->fd_d,p->size,p->len);char buf[p->len];int ret = read(p->fd_s,buf,p->len);write(p->fd_d,buf,ret);return NULL; 
}
#endifvoid * do_copy (void *arg)
{msg_t p = *(msg_t*)arg;lseek(p.fd_s,p.size*p.id,SEEK_SET);lseek(p.fd_d,p.size*p.id,SEEK_SET);printf("tid = %ld id = %d fd_s = %d fd_d = %d size = %d len = %d\n",pthread_self(),p.id,p.fd_s,p.fd_d,p.size,p.len);char buf[p.len];int ret = read(p.fd_s,buf,p.len);write(p.fd_d,buf,ret);return NULL; 
}//cp src dest 
int main(int argc, const char *argv[])
{if (argc!=3){printf("Usage: %s <src> <dest>\n",argv[0]);return -1;}int fd_s = open(argv[1],O_RDONLY);int fd_d = open(argv[2],O_WRONLY|O_TRUNC|O_CREAT,0666);if (fd_s < 0 || fd_d < 0){perror("open fail");return -1;}int n = 0;printf("Input threads num: ");scanf("%d",&n);int i = 0;int ret = 0;pthread_t tid[n];msg_t msg[n];struct stat st;if (stat(argv[1],&st) < 0){perror("stat fail");return -1;}int f_len = st.st_size;for (i = 0; i < n; ++i){//	msg.fd_s = fd_s;//	msg.fd_d = fd_d;//	msg.size = f_len / n;//	msg.id = i;msg[i].fd_s = fd_s;msg[i].fd_d = fd_d;msg[i].size = f_len / n;msg[i].id = i;if (i == n-1){ msg[i].len  = f_len - (f_len/n)*(n-1);}else {msg[i].len  = f_len/n;}ret = pthread_create(&tid[i],NULL,do_copy,&msg[i]);if (ret != 0){errno = ret;perror("pthread_create fail");return -1;}//		sleep(1);}printf("----main-----\n");for (i = 0; i < n; ++i)pthread_join(tid[i],NULL);close(fd_s);close(fd_d);return 0;
}


     
   
 

线程的属性的设置:


1. pthread_detach  //将指定的线程设置为分离状态 --- 那么资源的回收将自动完成
2. pthread_attr_setdetachstate   

   int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
   功能:
       设置线程的属性 
   参数：
       @attr --- 属性的对象 (变量)
       @detachstate --- 要设置的属性 
            PTHREAD_CREATE_DETACHED  //分离
             PTHREAD_CREATE_JOINABLE //结合 
  返回值
     成功 0
     失败 errno 
     //1.初始化 一个 属性的对象 
      int pthread_attr_init(pthread_attr_t *attr);
 
     //2.设置属性信息      
      int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
     //3.销毁      
     int pthread_attr_destroy(pthread_attr_t *attr);
 

atexit()


atexit();  //注册退出清理函数 
           //进程结束 
           //return  //main
           //exit 



void pthread_cleanup_push(void (*routine)(void *)， void *arg);

//线程退出清理函数:

    功能：注册一个线程清理函数
    参数，routine，线程清理函数的入口
                arg，清理函数的参数。
    返回值，无


        
void pthread_cleanup_pop(int execute);


    功能：调用清理函数
    execute，
            非0  执行清理函数
            0 ，不执行清理            
    返回值，无
    
注意:
   1.     使用时 pthread_cleanup_push  pthread_cleanup_pop 要一起用 ，需要在一个代码块 
 
    
触发方式:
   1.pthread_cleanup_pop(非零值)
   2.pthread_cleanup_pop(0) //pthread_exit() //退出动作会导致 触发 
    pthread_exit(NULL);
    pthread_cleanup_pop(0); 
   3.pthread_cancel(); //被其它线程结束时 
   


eg:
    定义要给全局变量 
    int cnt = 0;
    创建两个线程 --- 执行50000 
    每个线程 
    int temp = cnt;
    printf("cnt = %d\n",cnt);
    temp = temp + 1;
    cnt = temp;

#include<stdio.h>
#include<errno.h>
#include<pthread.h>
int cnt =0;
pthread_mutex_t mutex;
void*dosomething1(void*arg)
{int n=50000;while(n){	pthread_mutex_lock(&mutex);int temp =cnt;printf("cnt = %d\n",cnt);temp = temp+1;cnt = temp;pthread_mutex_unlock(&mutex);--n;}return NULL;
}
void*dosomething2(void*arg)
{int n=50000;while(n){	pthread_mutex_lock(&mutex);int temp =cnt;printf("cnt = %d\n",cnt);temp = temp+1;cnt = temp;pthread_mutex_unlock(&mutex);--n;}return NULL;
}
typedef void*(*pthread_cb_t)(void *);
int main(int argc, const char *argv[])
{pthread_t pid[2];int i=0;int ret;pthread_cb_t func[2]={dosomething1,dosomething2};for(i=0;i<2;i++){ret = pthread_create(&pid[i],NULL,func[i],NULL);if(ret!=0){errno = ret;perror("pthread_create fail");return -1;}}printf("-----------main-----------\n");pthread_join(pid[0],NULL);pthread_join(pid[1],NULL);return 0;
}

线程 对比 进程 

进程 
   优点
      进程空间独立 --- 更稳定 安全 可靠      
   缺点
      进程创建，调度效率低
      数据共享不方便 ---- 进程间通信
    
线程 
   优点
     创建，调度效率高 
     共享数据方便 
   缺点
      共享进程空间和资源 
      ---不稳定，不安全 
      共享数据 ---资源的竞争 
    
线程进阶:

   全局的cnt  ---- 共享资源(公共资源) --- 临界资源 
   临界区 --- 访问临界资源代码段 
   

   
   互斥操作  


   互斥 --- 排他性 
   原子性操作 --- 不可再分的操作 
     
    临界资源: 共享资源 
    临界区  : 一段代码区域(访问临界资源的那段代码)
    原子操作: 要么不操作，要操作，一定是一次完整的操作。不能被打断。
    
    概念：互斥 ===》在多线程中对临界资源的排他性访问。

    互斥机制 ===》互斥锁  ===》保证临界资源的访问控制。

    pthread_mutex_t   mutex;
    互斥锁类型        互斥锁变量 内核对象

    框架：


       定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
        ****                       ***      *** 
 
      //互斥锁 互斥量 
       pthread_mutex_init(); //初始化一把锁 
       pthread_mutex_lock(); //上锁 
       pthread_mutex_unlock(); //解锁 
       pthread_mutex_destroy();//销毁一把锁 
   


     1、定义：


        pthread_mutex_t   mutex;

     2、初始化锁


        int pthread_mutex_init(
            pthread_mutex_t *mutex,
            const pthread_mutexattr_t *attr);
        功能：将已经定义好的互斥锁初始化。
        参数：mutex 要初始化的互斥锁
              atrr  初始化的值，
              一般是NULL表示默认锁   //一般的锁 ，读写锁 
        返回值：成功 0
                失败 非零
        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //静态初始化 


     3、加锁：


        int pthread_mutex_lock(pthread_mutex_t *mutex);
        功能：用指定的互斥锁开始加锁代码
              加锁后的代码到解锁部分的代码属于原子操作，
              在加锁期间其他进程/线程都不能操作该部分代码
              如果该函数在执行的时候，mutex已经被其他部分
              使用则代码阻塞。

        参数： mutex 用来给代码加锁的互斥锁
        返回值：成功 0
                失败 非零

     4、解锁


        int pthread_mutex_unlock(pthread_mutex_t *mutex);
        功能：将指定的互斥锁解锁。
              解锁之后代码不再排他访问，一般加锁解锁同时出现。
        参数：用来解锁的互斥锁
        返回值：成功 0
                失败 非零

     5、销毁


         int pthread_mutex_destroy(pthread_mutex_t *mutex);
         功能：使用互斥锁完毕后需要销毁互斥锁
         参数：mutex 要销毁的互斥锁
         返回值：成功  0
                 失败  非零
 
注意:
   原则 --- 锁的区域 尽可能小 
          

eg:
   创建两个线程
   线程1 打印 hello
   线程2 打印 world

      

#include <stdio.h>
#include <pthread.h>
#include <errno.h>void* print_hello(void *arg)
{while (1){printf("hello ");}
}void* print_world(void *arg)
{while (1){printf("world\n");}
}int main(int argc, const char *argv[])
{pthread_t tid[2];int ret = 0;if ((ret = pthread_create(&tid[0],NULL,print_hello,NULL)) != 0){errno = ret;perror("pthread_create fail");return -1;}if ((ret = pthread_create(&tid[1],NULL,print_world,NULL)) != 0){errno = ret;perror("pthread_create fail");return -1;}printf("--main--\n");pthread_join(tid[0],NULL);pthread_join(tid[1],NULL);return 0;
}


       
 


   

http://www.dtcms.com/wzjs/138193.html

相关文章：

  • 劫持网站代做排名营销推广技巧
  • 我要做一个网站 需要营业范围吗网络营销品牌案例
  • 做企业网站用二级域名好吗百度推广客服投诉电话
  • 呼和浩特重大消息宁波seo运营推广平台排名
  • 金科科技 做网站电脑课程培训零基础
  • 深圳做网站排名哪家好网站页面的优化
  • 闲鱼怎么做钓鱼网站企业网站seo方案
  • 湖北武汉网站建设演艺搜索引擎查询
  • 初学者拟建网站朋友圈广告30元 1000次
  • 企业网站建设可行性网络整合营销理论
  • 山东旗舰建设集团网站海南网站网络推广
  • 顺德网站建seo关键词优化软件
  • 东莞企石做网站百度关键词搜索排名统计
  • 一台电脑如何做网站免费浏览网站推广
  • 网站建设单选题做百度推广的公司电话号码
  • 大连网站建设信息武汉seo关键词排名优化
  • 个人网站可以做哪些主题网盘资源免费观看
  • 做地铁建设的公司网站杭州seo软件
  • 鄂尔多斯网站制作公司我要登录百度
  • 云服务器和网站备案吗seo标题优化关键词怎么选
  • 长沙 网站设计 公司抖音seo什么意思
  • 做微信小程序网站国内做网站的公司
  • 网站价格全网营销推广公司
  • 网站title标签内容怎么设置南京seo网站管理
  • 吉林省人民政府门户网站首页关键词排名
  • 适合写论文的中小企业名录佛山抖音seo
  • 怎么做扫二维码登陆网站今天的新闻发布会
  • 深圳网站制作易捷网络2023年6月疫情情况
  • 知名网站建设公司社交媒体推广
  • 黔东南州两学一做教育网站怎么让自己上百度