4th

Posted 2023-04-15 wcy1111

肇事车牌

简单的方程问题

每一位车牌号 是0~9

 

#include <iostream>
using namespace std;
int main()
int a1,a2,a3,a4;
for(int a1=0;a1<=9;a1++)//for 循环 控制第一位数
a2=a1;//第一位与第二位相同
for(a3=0;a3<=9;a3++)//for循环控制第二位
a4=a3;//3 4位数相同
for(int i=0;i<100;i++) //整数的平方要小于四位数 所以控制到100以内
if((a1*1000+a2*100+a3*10+a4==i*i)&&a1!=a3) 
cout<<i*i<<endl;




return 0;

使用条件变量的线程间通信？

【中文标题】使用条件变量的线程间通信？

【英文标题】：Inter-thread communication using condition variables?

【发布时间】：2017-06-27 03:54:09

【问题描述】：

假设我在一个进程中有三个线程 th1、th2 和 th3 以及三个寄存器（数组）a、b 和 c。 th1 和 th2 仅写入三个寄存器之一，th3 将仅从这些寄存器读取数据。 th1、th2 和 th3 将按照等待条件变量的连续顺序 b/c 工作。两个条件变量 cv1 和 cv2 分别用于在 (th1,th2) 和 (th2,th3) 之间发送信号。工作程序如下：

首先 th1 将一些东西写入“a”数组，然后向等待它的 th2 发出信号（使用 cv1）。 在接收到来自 th1 的信号后，th2 开始写入同一个数组“a”，然后向 th3 发出信号（使用 cv2）读取“a”。 th3 在接收到来自 th2 的信号时开始读取“a”（相同的数组）。 “b”和“c”以相同方式重复上述 3 个步骤。

我的c代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pthread.h>

void* th1();
void* th2();
void* th3();

int a[40], b[40], c[40], rn;

pthread_mutex_t mutex1, mutex2, mutex3;
pthread_cond_t cv1, cv2;

int main()

    pthread_t  t[3];
    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);
    pthread_mutex_init(&mutex3, NULL);

    pthread_cond_init(&cv1, NULL);
    pthread_cond_init(&cv2, NULL);

    pthread_create(&t[0], NULL, th1, NULL);
    pthread_create(&t[1], NULL, th2, NULL);
    pthread_create(&t[2], NULL, th3, NULL);


    pthread_join(t[0], NULL);
    pthread_join(t[1], NULL);
    pthread_join(t[2], NULL);

    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);
    pthread_mutex_destroy(&mutex3);
    pthread_cond_destroy(&cv1);
    pthread_cond_destroy(&cv2);
    return 0;


void* th1()
       
    pthread_mutex_lock(&mutex1);
        for(int i=0; i<20; i++)
        
            a[i]=i;
            
        pthread_cond_signal(&cv1);
        puts("a signal sent...");
    pthread_mutex_unlock(&mutex1);


    pthread_mutex_lock(&mutex2);
        for(int i=0; i<20; i++)
        
            b[i]=i;
            
        pthread_cond_signal(&cv1);
        puts("b signal sent...");
    pthread_mutex_unlock(&mutex2);


    pthread_mutex_lock(&mutex3);
        for(int i=0; i<20; i++)
        
            c[i]=i;
            
        pthread_cond_signal(&cv1);
        puts("c signal sent...");
    pthread_mutex_unlock(&mutex3);

    pthread_exit(NULL);


void* th2()

    pthread_mutex_lock(&mutex1);
        pthread_cond_wait(&cv1, &mutex1);
        puts("signal recv form th1 for writing 'a'...\n");
        for(int i=0; i<=20; i++)
        
            a[i+20]=i+20;
        
        pthread_cond_signal(&cv2);
    pthread_mutex_unlock(&mutex1);


    pthread_mutex_lock(&mutex2);
        pthread_cond_wait(&cv1, &mutex2);
        puts("signal recv from th1 for writing 'b'...\n");
        for(int i=0; i<=20; i++)
        
            b[i+20]=i+20;
        
        pthread_cond_signal(&cv2);
    pthread_mutex_unlock(&mutex2);


    pthread_mutex_lock(&mutex3);
        pthread_cond_wait(&cv1, &mutex3);
        puts("signal recv from th1 for writing 'c'...\n");
        for(int i=0; i<=20; i++)
        
            c[i+20]=i+20;
        
        pthread_cond_signal(&cv2);
    pthread_mutex_unlock(&mutex3);

    pthread_exit(NULL);

void* th3()


    pthread_mutex_lock(&mutex1);
        pthread_cond_wait(&cv2, &mutex1);
        puts(" signal recv from th2 for reading 'a'...\n");
        for(int i=0; i<=40; i++)
        
            printf("%d   :",a[i]);
        
        printf("\n\n");
    pthread_mutex_unlock(&mutex1);


    pthread_mutex_lock(&mutex2);
        pthread_cond_wait(&cv2, &mutex2);
        puts(" signal recv from th2 for reading 'b'...\n");
        for(int i=0; i<=40; i++)
        
            printf("%d   :",b[i]);
        
        printf("\n\n");
    pthread_mutex_unlock(&mutex2);


    pthread_mutex_lock(&mutex3);
        pthread_cond_wait(&cv2, &mutex3);
        puts(" signal recv from th2 for reading 'c'...\n");
        for(int i=0; i<=40; i++)
        
            printf("%d   :",c[i]);
        
        printf("\n\n");
    pthread_mutex_unlock(&mutex3);

    pthread_exit(NULL);

仅显示后的输出块：

mohtashim-ul-haq@mohtashim-pc:~/Documents/rough$ gcc tread.c -o tread -lpthread
mohtashim-ul-haq@mohtashim-pc:~/Documents/rough$ ./tread
a signal sent...
b signal sent...
c signal sent...

我的预期输出是这样的：

    a signal sent
    signal recv form th1 for writing 'a'...
    signal recv from th2 for reading 'a'...
    1 2 3 4 ..... 40

    b signal sent
    signal recv form th1 for writing 'b'...
    signal recv from th2 for reading 'b'...
    1 2 3 4 ..... 40

    c signal sent
    signal recv form th1 for writing 'c'...
    signal recv from th2 for reading 'c'...
    1 2 3 4 ..... 40

我想，我无法理解条件变量如何与互斥锁结合使用。有什么帮助？？？

【问题讨论】：

第一个线程在任何其他线程开始之前运行，即cond_signal 在其他线程有时间发送到wait 之前被发送，然后它们在wait 中被进一步阻塞。跨度>

有什么解决办法？？？

【参考方案1】：

你需要整合事件“信号”，如果信号（通知状态改变）被提出，你会说你需要存储。

对于第一个事件（“a”读取），您的代码调整可能如下所示：

int a_read = 0; /* to store the event "a had been read" actually happened */

void* th1(void * pvunused)
       
    pthread_mutex_lock(&mutex1);
    for(int i=0; i<20; i++)
    
        a[i]=i;
    

    a_read = 1;
    pthread_cond_signal(&cv1);
    ...


void* th2(void * pvunused)

  pthread_mutex_lock(&mutex1);
  while (0 == a_read) /* Theoretical an "if" would do here, 
                         using "while" lets you stay on the safe side, in case
                         a "spurious wake-up" (https://en.wikipedia.org/wiki/Spurious_wakeup)
                         occurred. */
  
    pthread_cond_wait(&cv1, &mutex1);
  

  ...

【讨论】：

完美！这意味着阻塞等待调用不会自动接收来自其他线程的信号，而是需要不断检查来自被调用线程的某个“work_end_flag”...

@mohtashim：“阻塞等待调用不会自动接收来自其他线程的信号”肯定会.. 如果这个“其他”线程是已经在等了。如果它还没有等待条件发出信号，它会错过它，这就是为什么需要存储它发出信号的事实，这是由相关的条件变量完成的。

假设一个案例，如果我有误解，请告诉我正确的概念：th1 首先运行，mutex_lock 和 mutex_unlock 之间的原子代码设置 a_read == 1.之后 th2 运行 where while (0 == a_read)获取失败 (b/c a_read == 1) 所以实际上 th2 中的 pthread_cond_wait(&cv1, &mutex1) 不会收到任何信号，而 while 循环之外的其他代码只会执行......

案例 2：如果 th2 先运行，那么它将等待来自 th1 的信号 (b/c a_read==0)。当 th1 运行时，它设置 a_read == 1 并发送信号，该信号将被 th2 接收。这意味着这里不需要 a_read 标志，即 th2 已经在等待来自 th1 的信号？？？

@mohtashim：案例 1 和 2 都可以使用显示的代码出现，所以是的，标志 a_read 将覆盖案例 1 ... 和覆盖线程意外唤醒的情况。请阅读我在代码评论中添加的链接。