多线程编程实例练习

最新推荐文章于 2024-04-15 07:17:05 发布
最新推荐文章于 2024-04-15 07:17:05 发布
阅读量2.4k 收藏 7
点赞数 2
分类专栏： C语言 编程语言 多线程编程笔记 文章标签： 实例 多线程 编程 线程 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/viewsky11/article/details/54381433
版权

pthread_join使一个线程等待另一个线程结束。代码中如果没有pthread_join主线程会很快结束从而使整个进程结束，从而使创建的线程没有机会开始执行就结束了。加入pthread_join后，主线程会一直等待直到等待的线程结束自己才结束，使创建的线程有机会执行。

#include <pthread.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  

void *thread_function(void *arg);    
char message[] = "Hello World";  

int main()  
{  
    int res;  
    pthread_t a_thread;  
    void *thread_result;  

    res = pthread_create(&a_thread, NULL, thread_function, (void *)message);  
    if (res != 0)  
    {  
        perror("Thread creation failed!");  
        exit(EXIT_FAILURE);  
    }  

    printf("Waiting for thread to finish...\n");  

    res = pthread_join(a_thread, &thread_result);  
    if (res != 0)  
    {  
        perror("Thread join failed!\n");  
        exit(EXIT_FAILURE);  
    }  

    printf("Thread joined, it returned %s\n", (char *)thread_result);  
    printf("Message is now %s\n", message);  

    exit(EXIT_FAILURE);  
}  

void *thread_function(void *arg)  
{  
    printf("thread_function is running. Argument was %s\n", (char *)arg);  
    sleep(3);  
    strcpy(message, "Bye!");  
    pthread_exit("Thank you for your CPU time!");  
}

线程同步 

#include <pthread.h>  
#include <stdio.h>  
#include <stdlib.h>  

int flag = 1;    
void *thread_function(void *arg);  

int main()  
{  
    int res;  
    pthread_t a_thread;  
    void *thread_result;  
    int count = 1;  

    res = pthread_create(&a_thread, NULL, thread_function, NULL);  
    if (res != 0)  
    {  
        perror("Thread creation failed");  
        exit(EXIT_FAILURE);  
    }  

    while (count++ <= 20)  
    {  
        if (flag == 1)  
        {  
            printf ("1");  
            flag = 2;  
        }  
        else  
        {  
            sleep(1);  
        }  
    }  

    printf("\nWaiting for thread to finish...\n");  
    res = pthread_join(a_thread, &thread_result);  
    if (res != 0)  
    {  
        perror("Thread join failed");  
        exit(EXIT_FAILURE);  
    }  

    exit(EXIT_SUCCESS);  
}  

void *thread_function(void *arg)  
{  
    int count = 1;  

    while (count++ <= 20)  
    {  
        if (flag == 2)  
        {  
            printf("2");  
            flag = 1;  
        }  
        else  
        {  
            sleep(1);  
        }  
    }  
}

设置线程为detachstate属性。表示新线程是否与进程中其他线程脱离同步，如果设置为PTHREAD_CREATE_DETACHED则新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源。缺省为PTHREAD_CREATE_JOINABLE状态。这个属性也可以在线程创建并运行以后用pthread_detach()来设置，而一旦设置为PTHREAD_CREATE_DETACH状态（不论是创建时设置还是运行时设置）则不能再恢复到PTHREAD_CREATE_JOINABLE状态

#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <pthread.h>  

void *thread_function(void *arg);  

char message[] = "Hello World";  
int thread_finished = 0;  

int main()  
{  
    int res;  
    pthread_t a_thread;  
    pthread_attr_t thread_attr;  

    res = pthread_attr_init(&thread_attr);  
    if (res != 0)  
    {  
        perror("Attribute creation failed");  
        exit(EXIT_FAILURE);  
    }  

    res = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);  
    if (res != 0)  
    {  
        perror("Setting detached attribute failed");  
        exit(EXIT_FAILURE);  
    }  

    res = pthread_create(&a_thread, &thread_attr, thread_function, (void*)message);  
    if (res != 0)  
    {  
        perror("Thread creation failed");  
        exit(EXIT_FAILURE);  
    }  

    pthread_attr_destroy(&thread_attr);  
    while(!thread_finished)  
    {  
        printf("Waiting for thread to say it's finished...\n");  
        sleep(1);  
    }  

    printf("Other thread finished, bye!\n");  
    exit(EXIT_SUCCESS);  
}  

void *thread_function(void *arg)  
{  
    printf("thread_function is running. Argument was %s\n", (char *)arg);  
    sleep(4);  
    printf("Second thread setting finished flag, and exiting now\n");  
    thread_finished = 1;  
    pthread_exit(NULL);  
}

线程的被动结束分为两种，一种是异步终结，另外一种是同步终结。异步终结就是当其他线程调用 pthread_cancel的时候，线程就立刻被结束。而同步终结则不会立刻终结，它会继续运行，直到到达下一个结束点（cancellation point）

#include <pthread.h>  
#include <stdio.h>  
#include <stdlib.h>  

void *thread_function(void *arg);  

int main()  
{  
    int res;  
    pthread_t a_thread;  
    void *thread_result;  

    res = pthread_create(&a_thread, NULL, thread_function, NULL);  
    if (res != 0)  
    {  
        perror("Thread create failed!");  
        exit(EXIT_FAILURE);  
    }  

    sleep(4);  
    printf("Canceling thread...\n");  

    res = pthread_cancel(a_thread);  
    if (res != 0)  
    {  
        perror("Thread cancel failed!");  
        exit(EXIT_FAILURE);  
    }  

    printf ("Waiting for thread to finished...\n");  

    res = pthread_join(a_thread, &thread_result);  
    if (res != 0)  
    {  
        perror ("Thread join failed!");  
        exit(EXIT_FAILURE);  
    }  

    printf("Thread canceled!");  

    exit(EXIT_FAILURE);  
}  

void *thread_function(void *arg)  
{  
    int i;  
    int res;  

    res = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);  
    if (res != 0)  
    {  
        perror("Thread setcancelstate failed!");  
        exit(EXIT_FAILURE);  
    }  

    res = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);  
    if (res != 0)  
    {  
        perror("Thread setcanceltype failed!");  
        exit(EXIT_FAILURE);  
    }  

    printf("thread_function is running...\n");  

    for (i = 0; i < 10; i++)  
    {  
        printf("Thread is still running (%d)...\n", i);  
        sleep(1);  
    }  
    pthread_exit(0);  
}

多线程编程 

#include <pthread.h>  
#include <stdio.h>  
#include <stdlib.h>  

#define NUM 6  

void *thread_function(void *arg);  

int main()  
{  
    int res;  
    pthread_t a_thread[NUM];  
    void *thread_result;  
    int index;  

    for (index = 0; index < NUM; ++index) {  
        res = pthread_create(&a_thread[index], NULL, thread_function, (void *)index);  
        if (res != 0)  
        {  
            perror("Thread create failed!");  
            exit(EXIT_FAILURE);  
        }  
        sleep(1);  
    }  

    printf("Waiting for threads to finished...\n");  

    for (index = NUM - 1; index >= 0; --index)  
    {  
        res = pthread_join(a_thread[index], &thread_result);  
        if (res == 0)  
        {  
            printf("Picked up a thread:%d\n", index + 1);  
        }  
        else  
        {  
            perror("pthread_join failed\n");  
        }  
    }  

    printf("All done\n");  

    exit(EXIT_SUCCESS);  
}  

void *thread_function(void *arg)  
{  
    int my_number = (int)arg;  
    int rand_num;  

    printf("thread_function is running. Argument was %d\n", my_number);  
    rand_num = 1 + (int)(9.0 * rand()/(RAND_MAX + 1.0));  
    sleep(rand_num);  
    printf("Bye from %d\n", my_number);  
    pthread_exit(NULL);  
}

使用信号量进行线程同步

#include <pthread.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <semaphore.h>  

#define SIZE 1024   
void *thread_function(void *arg);  

char buffer[SIZE];  
sem_t sem;  

int main()  
{  
    int res;  
    pthread_t a_thread;  
    void *thread_result;  

    res = sem_init(&sem, 0, 0);  
    if (res != 0)  
    {  
        perror("Sem init failed");  
        exit(EXIT_FAILURE);  
    }  

    res = pthread_create(&a_thread, NULL, thread_function, NULL);  
    if (res != 0)  
    {  
        perror("Thread create failed");  
        exit(EXIT_FAILURE);  
    }  

    printf("Input some text. Enter 'end' to finish\n");  

    while (scanf("%s", buffer))  
    {  
        sem_post(&sem);  
        if (strncmp("end", buffer, 3) == 0)  
            break;  
    }  

    printf ("\nWaiting for thread to finish...\n");  

    res = pthread_join(a_thread, &thread_result);  
    if (res != 0)  
    {  
        perror("Thread join failed");  
        exit(EXIT_FAILURE);  
    }  

    printf ("Thread join\n");  

    sem_destroy(&sem);    
    exit(EXIT_SUCCESS);  
}  

void *thread_function(void *arg)  
{  
    sem_wait(&sem);  
    while (strncmp("end", buffer, 3) != 0)  
    {  
        printf("You input %d characters\n", strlen(buffer));  
        sem_wait(&sem);  
    }  
    pthread_exit(NULL);  
}

线程优先级调度

#include <stdio.h>
#include <pthread.h>
#include <sched.h>
#include <assert.h>

static int api_get_thread_policy (pthread_attr_t *attr)
{
    int policy;
    int rs = pthread_attr_getschedpolicy (attr, &policy);
    assert (rs == 0);

    switch (policy)
    {
        case SCHED_FIFO:
            printf ("policy = SCHED_FIFO\n");
            break;
        case SCHED_RR:
            printf ("policy = SCHED_RR");
            break;
        case SCHED_OTHER:
            printf ("policy = SCHED_OTHER\n");
            break;
        default:
            printf ("policy = UNKNOWN\n");
            break; 
    }
    return policy;
}

static void api_show_thread_priority (pthread_attr_t *attr,int policy)
{
    int priority = sched_get_priority_max (policy);
    assert (priority != -1);
    printf ("max_priority = %d\n", priority);
    priority = sched_get_priority_min (policy);
    assert (priority != -1);
    printf ("min_priority = %d\n", priority);
}

static int api_get_thread_priority (pthread_attr_t *attr)
{
    struct sched_param param;
    int rs = pthread_attr_getschedparam (attr, &param);
    assert (rs == 0);
    printf ("priority = %d\n", param.__sched_priority);
    return param.__sched_priority;
}

static void api_set_thread_policy (pthread_attr_t *attr,int policy)
{
    int rs = pthread_attr_setschedpolicy (attr, policy);
    assert (rs == 0);
    api_get_thread_policy (attr);
}

int main(void)
{
    pthread_attr_t attr;       // 线程属性
    struct sched_param sched;  // 调度策略
    int rs;

    /* 
     * 对线程属性初始化
     * 初始化完成以后，pthread_attr_t 结构所包含的结构体
     * 就是操作系统实现支持的所有线程属性的默认值
     */
    rs = pthread_attr_init (&attr);
    assert (rs == 0);     // 如果 rs 不等于 0，程序 abort() 退出

    /* 获得当前调度策略 */
    int policy = api_get_thread_policy (&attr);

    /* 显示当前调度策略的线程优先级范围 */
    printf ("Show current configuration of priority\n");
    api_show_thread_priority(&attr, policy);

    /* 获取 SCHED_FIFO 策略下的线程优先级范围 */
    printf ("show SCHED_FIFO of priority\n");
    api_show_thread_priority(&attr, SCHED_FIFO);

    /* 获取 SCHED_RR 策略下的线程优先级范围 */
    printf ("show SCHED_RR of priority\n");
    api_show_thread_priority(&attr, SCHED_RR);

    /* 显示当前线程的优先级 */
    printf ("show priority of current thread\n");
    int priority = api_get_thread_priority (&attr);

    /* 手动设置调度策略 */
    printf ("Set thread policy\n");

    printf ("set SCHED_FIFO policy\n");
    api_set_thread_policy(&attr, SCHED_FIFO);

    printf ("set SCHED_RR policy\n");
    api_set_thread_policy(&attr, SCHED_RR);

    /* 还原之前的策略 */
    printf ("Restore current policy\n");
    api_set_thread_policy (&attr, policy);

    /* 
     * 反初始化 pthread_attr_t 结构
     * 如果 pthread_attr_init 的实现对属性对象的内存空间是动态分配的，
     * phread_attr_destory 就会释放该内存空间
     */
    rs = pthread_attr_destroy (&attr);
    assert (rs == 0);

    return 0;
}

线程互斥锁 

#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h>
#include <malloc.h> 

typedef struct  
 { 
   double      *a; 
   double      *b; 
   double     sum;  
   int     veclen;  
 } DOTDATA; 

#define NUMTHRDS 4 
#define VECLEN 100 
   DOTDATA dotstr;  
   pthread_t callThd[NUMTHRDS]; 
   pthread_mutex_t mutexsum; 

void *dotprod(void *arg) 
{ 

   /* Define and use local variables for convenience */ 

   int i, start, end, offset, len ; 
   double mysum, *x, *y; 
   offset = (int)arg; 

   len = dotstr.veclen; 
   start = offset*len; 
   end   = start + len; 
   x = dotstr.a; 
   y = dotstr.b; 

   mysum = 0; 
   for (i=start; i<end ; i++)  
    { 
      mysum += (x[i] * y[i]); 
    } 

   pthread_mutex_lock (&mutexsum); 
   dotstr.sum += mysum; 
   pthread_mutex_unlock (&mutexsum); 

   pthread_exit((void*) 0); 
} 


int main (int argc, char *argv[]) 
{ 
   int i; 
   double *a, *b; 
   void *status; 
   pthread_attr_t attr; 

   a = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double)); 
   b = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double)); 

   for (i=0; i<VECLEN*NUMTHRDS; i++) 
    { 
     a[i]=1.0; 
     b[i]=a[i]; 
    } 

   dotstr.veclen = VECLEN;  
   dotstr.a = a;  
   dotstr.b = b;  
   dotstr.sum=0; 

   pthread_mutex_init(&mutexsum, NULL); 

   pthread_attr_init(&attr); 
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 

        for(i=0; i<NUMTHRDS; i++) 
        { 
        pthread_create( &callThd[i], &attr, dotprod, (void *)i); 
        } 

        pthread_attr_destroy(&attr); 

        for(i=0; i<NUMTHRDS; i++) 
        { 
          pthread_join( callThd[i], &status); 
        } 

   printf ("Sum =  %f \n", dotstr.sum); 
   free (a); 
   free (b); 
   pthread_mutex_destroy(&mutexsum); 
   pthread_exit(NULL); 
}

线程中使用条件变量

#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h>

#define NUM_THREADS  3 
#define TCOUNT 10 
#define COUNT_LIMIT 12 

int     count = 0; 
int     thread_ids[3] = {0,1,2}; 
pthread_mutex_t count_mutex; 
pthread_cond_t count_threshold_cv; 

void *inc_count(void *idp)  
{ 
  int j,i; 
  double result=0.0; 
  int *my_id = idp; 

  for (i=0; i<TCOUNT; i++) { 
    pthread_mutex_lock(&count_mutex); 
    count++; 

    if (count == COUNT_LIMIT) { 
      pthread_cond_signal(&count_threshold_cv); 
      printf("inc_count(): thread %d, count = %d  Threshold reached.\n", *my_id, count); 
      } 
    printf("inc_count(): thread %d, count = %d, unlocking mutex\n", *my_id, count); 
    pthread_mutex_unlock(&count_mutex); 

    for (j=0; j<1000; j++) 
      result = result + (double)random(); 
    } 
  pthread_exit(NULL); 
} 

void *watch_count(void *idp)  
{ 
  int *my_id = idp; 

  printf("Starting watch_count(): thread %d\n", *my_id); 

  pthread_mutex_lock(&count_mutex); 
  if (count<COUNT_LIMIT) { 
    pthread_cond_wait(&count_threshold_cv, &count_mutex); 
    printf("watch_count(): thread %d Condition signal received.\n", *my_id); 
    } 
  pthread_mutex_unlock(&count_mutex); 
  pthread_exit(NULL); 
} 

int main (int argc, char *argv[]) 
{ 
  int i, rc; 
  pthread_t threads[3]; 
  pthread_attr_t attr; 

  pthread_attr_init(&attr); 
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 
  pthread_create(&threads[0], &attr, inc_count, (void *)&thread_ids[0]); 
  pthread_create(&threads[1], &attr, inc_count, (void *)&thread_ids[1]); 
  pthread_create(&threads[2], &attr, watch_count, (void *)&thread_ids[2]); 

  for (i=0; i<NUM_THREADS; i++) { 
    pthread_join(threads[i], NULL); 
  } 
  printf ("Main(): Waited on %d  threads. Done.\n", NUM_THREADS); 

  pthread_attr_destroy(&attr); 
  pthread_mutex_destroy(&count_mutex); 
  pthread_cond_destroy(&count_threshold_cv); 
  pthread_exit(NULL); 

}

设置线程栈 

#include <pthread.h> 
#include <stdio.h> 
#include <stdlib.h>

#define NTHREADS 4 
#define N 1000 
#define MEGEXTRA 1000000 

pthread_attr_t attr; 

void *dowork(void *threadid) 
{ 
   double A[N][N]; 
   int i,j,tid; 
   size_t mystacksize; 

   tid = (int)threadid; 
   pthread_attr_getstacksize (&attr, &mystacksize); 
   printf("Thread %d: stack size = %li bytes \n", tid, mystacksize); 
   for (i=0; i<N; i++) 
     for (j=0; j<N; j++) 
      A[i][j] = ((i*j)/3.452) + (N-i); 
   pthread_exit(NULL); 
} 

int main(int argc, char *argv[]) 
{ 
   pthread_t threads[NTHREADS]; 
   size_t stacksize; 
   int rc, t; 

   pthread_attr_init(&attr); 
   pthread_attr_getstacksize (&attr, &stacksize); 
   printf("Default stack size = %li\n", stacksize); 
   stacksize = sizeof(double)*N*N+MEGEXTRA; 
   printf("Amount of stack needed per thread = %li\n",stacksize); 
   pthread_attr_setstacksize (&attr, stacksize); 
   printf("Creating threads with stack size = %li bytes\n",stacksize); 
   for(t=0; t<NTHREADS; t++){ 
      rc = pthread_create(&threads[t], &attr, dowork, (void *)t); 
      if (rc){ 
         printf("ERROR; return code from pthread_create() is %d\n", rc); 
         exit(-1); 
      } 
   } 
   printf("Created %d threads.\n", t); 
   pthread_exit(NULL); 
}
viewsky11
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程编程例子
Pop_Rain的博客
03-11 645
title: 多线程编程例子 date: 2019-10-1 19:00:08 updated: 2020-02-27 19:04:06 categories: 多线程 tags: - 多线程 本博文记录多线程编程的几个案例，包含了常见的几种多线程编程套路。 1.四个线程计算1到100的求和 1.依次调用thread.join()，主线程输出结果。注意：sum为共享变量，访问共享变量时，用s...
多线程编程实现方式
AuroraCD的博客
05-09 923
区分多线程与进程： 进程是受OS管理的基本运行单元，也就是“一次程序的执行”； 多线程则可以理解成在进程中独立运行的子任务，他们可以同时运行。 使用多线程的优点： 直观地，比如Windows（多任务操作系统）可以最大限度地使用CPU的空闲时间来处理其他任务，CPU在不同的任务之间不停地切换，由于切换的速度很快，我们就觉得这些任务好像是在同时运行。So，使用多线程可以在同一时间内运行更多不同类型...
Java 多线程练习
qq_57570052的博客
07-28 2179
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
多线程编程练习
kking_edc的博客
09-23 211
一、多线程交替打印ABC 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。 1.1 synchronized同步 public class test { public static class ThreadPrinter implements Runnable{ private String name; private Object pre
java多线程使用详解与案例，超详细
最新发布
z1667002的博客
04-15 1058
文章中涉及到的知识点我都已经整理成了资料，录制了视频供大家下载学习，诚意满满，希望可以帮助在这个行业发展的朋友，在论坛博客等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我把这些资料，分享出来。相信对于已经工作和遇到技术瓶颈的朋友们，在这份资料中一定都有你需要的内容。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
多线程案例
lfm1010123的博客
07-19 656
一、单例模式 二、阻塞式队列 三、定时器 四、线程池 五、工厂模式
delphi xls 线程_多线程练习：龟兔赛跑
weixin_39818727的博客
11-05 170
首先是需求：1. 用两个线程分别模拟乌龟和兔子奔跑。兔子和乌龟的速度不同。2. 两个线程共同跑完总长1000米。3. 同一时间只能有一个在跑，另一个处于休息状态。（兔子和乌龟严格轮流交替跑）4. 当总长度跑完以后，两个线程结束。5. 当两个线程都结束后，打印"到达终点"。6. 分别输出乌龟和兔子奔跑的距离。分析：1.首先需要确定使用什么方式创建线程，这里我们选用实现Runnable接口方式进行创建...
多线程练习（龟兔赛跑）
m0_46080170的博客
04-27 1643
龟兔赛跑的故事里，兔子在比赛过程中睡觉输掉了比赛，乌龟赢得最终的比赛。 我们就用龟兔赛跑这个小案例来练习一下我们的多线程。 直接上代码： package com.kuang.thread; /** * @ClassName Race * @Description 龟兔赛跑 * @Author 麻虾 * @Date 2021/4/25 14:07 07 * @Version 1.0 */ public class Race implements Runnable { //赛道
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
VC++多线程编程实例讲解
11-02
在VC++环境中进行多线程编程是开发高效并发应用...提供的"VC++多线程编程实例讲解.doc"文档和"多线程实例源码"将帮助你更直观地理解这些概念，并通过实例进行练习。记得在实践中不断探索和优化，提升多线程编程技能。
java多线程编程实现下雪效果
09-03
总结来说，这个Java多线程下雪效果的实现涉及了Java Swing组件、多线程编程、图形绘制以及匿名内部类等核心概念。通过这个例子，开发者不仅可以学习到如何创建具有动态效果的GUI应用，还能深入理解Java并发编程的...
CC++多线程编程练习题大全
06-12
CC++多线程编程练习题大全，非常适合学习编程的人们。
java基础多线程练习题（1）
08-08
java基础之多线程的练习题，博客访问地址： http://blog.csdn.net/u014028392/article/details/76906801
多线程实例
04-19
这些文件名称如6-17.c到6-20.c等，可能代表了不同的线程编程练习，每个文件可能包含一个具体的多线程应用场景。 在面向对象程序设计中，设计多态性是另一个重要的概念。多态性使得我们可以使用一个基类指针或引用...
python并发编程之多线程
01-27
总之，Python的多线程编程需要理解GIL的作用以及何时使用Lock来保护共享资源。虽然GIL限制了多线程的并行计算能力，但在I/O密集型任务中，多线程仍然能提高程序效率。而如果需要充分利用多核CPU，应考虑使用`...
OpenWrt编译
cc的专栏
10-26 5114
首先，你需要一台电脑，安装一个ubuntu，这个电脑可以用虚拟机，也可以用普通的电脑另外最好学一下llinux基础，最好英文基础也有。。。。。比如。。。我上次见到一个人用了sudo rm -rf /    表示吓尿了{:soso_e136:}还有请自备梯子，没梯子是编译不出来的（很多库都是google的）从官网下载ubuntu，我下的是ubuntukylin 14.04 64位桌面版，虚拟机的话推...
多线程例题练手(c入门)
weixin_42455006的博客
04-02 493
使用pthreads进行实时编程 需要模板代码critical.c和multithread.c。 /* * critical.c * * Demonstrate use of mutual exclusion using mutexes * * Upper case output indicates critical output * lower case output indicates non-critical output * * compile with gcc critical.
java多线程卖票案例练习
05-26 694
java多线程卖票案例(阻塞队列(ArrayBlockingQueue)) 题目需求: 代码实现火车站3个窗口同时卖25张车票的逻辑,同一个窗口不能卖同一张票 public class Window { public Window(String name) { this.name = name; } public Window() { } // 私有的当前票 public static Ticket ticket; // 窗口名
给我几个可以用来练习线程的案例
weixin_35757531的博客
12-26 110
好的，这里给出几个可以用来练习线程的案例： 实现一个多线程的数字计数器，每个线程分别计数一个不同的数字，最后输出所有线程计数的总和。 实现一个多线程的生产者-消费者模型，其中生产者线程生产某种物品，消费者线程消费物品，并且在物品数量达到一定值时通知生产者停止生产。 实现一个多线程的文件下载器，每个线程分别下载文件的不同部分，最后将所有部分合并成一个完整的文件。 实现一个多线程的计算器，每个...
java多线程实例练习题答案.pdf
11-26
本资源是一份关于Java多线程实例练习题的答案文档，主要针对Java编程中的多线程概念进行了详细的讲解和习题测试。以下知识点涵盖在其中： 1. **类间继承关系**：Java语言中，类之间的继承关系是单重的，这意味着一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值