C++ dividir um vetor para duas threads

[aknup]

Boa tarde,estou querendo dividir um vetor de 100 posições para duas threads;

gostaria de saber como faço para pegar inicio  que seria 0 e o fim que seria 49,depois o inicio  da thread 2 que seria 50 e o fim que seria 99.

[Visitante]

@aknup Olá. Eu não estudei ainda sobre programação multithread em C e C++, mas vi alguma coisinha disso em Java e Python 

Só que em Python vou passar apenas uma forma de imprimir os números de 0 a 99 usando 2 threads (com vetor sei não se conseguiria ainda):

import threading


class MyThread(threading.Thread):

    def __init__(self, i, j):
        threading.Thread.__init__(self)
        self.i = i
        self.j = j

    def run(self):
        self.imprimir()

    def imprimir(self):
        with condition:
            for num in range(self.i, self.j):
                print('[%s] %2d' % (self.name, num))


if __name__=='__main__':

    condition = threading.Condition()

    m1 = MyThread(0, 50)
    m1.start()

    m2 = MyThread(50, 100)
    m2.start()

    m1.join()
    m2.join()

    print()
    print('Exiting Main Thread')

É só para dar uma ideia de como fazer em C++  rs...

Boa sorte!

 

obs: Sou vibrado em programação multithread, apesar de não saber muito ainda sobre o assunto (mas entendo a lógica)

[Visitante]

@aknup Olá. Segue uma forma de fazer isso em Java (sintaxe mais parecida com a do C++) apenas para te dar uma ideia:

 

Classe MyThread:

public class MyTrhead extends Thread {

    private int i;
    private int j;
    private String nome;
    private int my_array[] = new int[100];

    public MyTrhead(String nome, int[] my_array, int i, int j) {
        this.nome = nome;
        this.my_array = my_array;
        this.i = i;
        this.j = j;
    }

    @Override
    public void run() {
        imprimir();
    }

    public synchronized void imprimir() {

        for (int x = i; x < j; x++) {
            System.out.println("[" + nome + "] array[" + x + "] = " + my_array[x]);
        }
    }
}

Classe com o método main:

public class Aplicacao {

    public static void main(String[] args) {

        int my_array[] = new int[100];

        for (int i = 0; i < my_array.length; i++) {
            my_array[i] = i;
        }

        MyTrhead m1 = new MyTrhead("Thread_1", my_array, 0, 50);
        m1.start();

        try {
            m1.join(); // espera a thread 1 terminar sua execução
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        MyTrhead m2 = new MyTrhead("Thread_2", my_array, 50, 100);
        m2.start(); // inicia a thread 2

        try {
            m2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Agora é só se virar para resolver isso em C++ amigo. Não estudei sobre isso ainda em C e C++, como já disse

 

Me empolguei com esse negócio rs...

[Visitante]

@aknup Olá. Agora andei estudando um pouco sobre programação multi threads em C e algo assim o exercício que você quer fazer:

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

int vetor[100];

void* parte_um_vetor(void* arg) {
    int i;
    for (i = 0; i < 50; i++) {
        printf("[%s]: vetor[%2d] = %3d\n", (char*)arg, i, vetor[i]);
    }
    printf("%s terminou sua execucao\n", (char*)arg);
    pthread_exit(arg);
}

void* parte_dois_vetor(void* arg) {
    int i;
    for (i = 50; i < 100; i++) {
        printf("[%s]: vetor[%2d] = %3d\n", (char*)arg, i, vetor[i]);
    }
    printf("%s terminou sua execucao\n", (char*)arg);
    pthread_exit(arg);
}

int main() {

    pthread_t threads[2];
    int i;

    for (i = 0; i < 100; i++) {
        vetor[i] = i; // preenche o vetor com números de 0 a 99
    }

    pthread_create(&threads[0], NULL, parte_um_vetor, (void*)("Thread_1")); // cria a thread 1

    printf("Thread_1 iniciada...\n");

    pthread_join(threads[0], NULL); // espera a thread 1 finalizar a sua execução

    sleep(3);

    printf("Thread_2 iniciada...\n");

    pthread_create(&threads[1], NULL, parte_dois_vetor, (void*)("Thread_2")); // cria a thread 2

    pthread_join(threads[1], NULL); // espera a thread 2 finalizar a sua execução

    return 0;
}

Só que estou só começando a estudar sobre isso em C e, sendo sincero, pareceu menos intuitivo do que em Java e Python rs..

Obs: Desculpa a demora em responder

Só não sei como roda no Windows(não testei ainda). No Linux é preciso compilar o código dessa forma:

gcc seu_codigo.c -o seu_codigo -lpthread
// e, para executar
./seu_codigo

 

[aknup]

Valeu,demorei um pouco pra responder porque não vi as notificações mais mesmo assim ajuda,principalmente a do java que eu tô vendo agora

4 horas atrás, r_Tray disse:

@aknup Olá. Agora andei estudando um pouco sobre programação multi threads em C e algo assim o exercício que você quer fazer:

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

int vetor[100];

void* parte_um_vetor(void* arg) {
    int i;
    for (i = 0; i < 50; i++) {
        printf("[%s]: vetor[%2d] = %3d\n", (char*) arg, i, vetor[i]);
    }
    pthread_exit(arg);
}

void* parte_dois_vetor(void* arg) {
    int i;
    for (i = 50; i < 100; i++) {
        printf("[%s]: vetor[%2d] = %3d\n", (char*) arg, i, vetor[i]);
    }
    pthread_exit(arg);
}

int main() {

    pthread_t threads[2];    
    void* thread_resposta;
    int i;

    for (i = 0; i < 100; i++) {
        vetor[i] = i; // preenche o vetor de 0 a 99
    }

    pthread_create(&threads[0], NULL, parte_um_vetor, (void *)("Thread_1")); // cria a thread 1

    printf("Thread 1 iniciada...\n");

    pthread_join(threads[0], &thread_resposta); // espera a thread 1 finalizar a sua execução

    sleep(3);

    printf("Thread 2 iniciada...\n");

    pthread_create(&threads[1], NULL, parte_dois_vetor, (void *)("Thread_2")); // cria a thread 2

    pthread_join(threads[1], &thread_resposta); // espera a thread 2 finalizar a sua execução

    return 0;
}

Só que estou só começando a estudar sobre isso em C e, sendo sincero, pareceu menos intuitivo do que em Java e Python rs..

Obs: Desculpa a demora em responder

Só não sei como roda no Windows(não testei ainda). No Linux é preciso compilar o código dessa forma:

gcc seu_codigo.c -o seu_codigo -lpthread
// e, para executar
./seu_codigo