C++面向对象（OOP）编程-线程返回值

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

void *print_hello(void *arg) {
    printf("Hello from thread %ld\n", (long)arg);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    int rc1, rc2;
    long t1 = 1, t2 = 2;

    /* Create independent threads each of which will execute function */
    rc1 = pthread_create(&thread1, NULL, print_hello, (void *)t1);
    if (rc1) {
        fprintf(stderr, "Error: Unable to create thread %d", rc1);
        exit(-1);
    }
    rc2 = pthread_create(&thread2, NULL, print_hello, (void *)t2);
    if (rc2) {
        fprintf(stderr, "Error: Unable to create thread %d", rc2);
        exit(-1);
    }

    /* Wait till threads are complete before main continues. */
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

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

void * add1_handler(void *arg)
{
    int *ret = (int*)malloc(sizeof(int));

    *ret = *((int*)arg) + 1;
    return ret;
}

int main() {
    pthread_t thread1;
    int in = 34;
    int rc1 = 0;
    /* Create independent threads each of which will execute function */
    rc1 = pthread_create(&thread1, NULL, add1_handler, (void*)&in);
    if (rc1) {
        fprintf(stderr, "Error: Unable to create thread %d", rc1);
        exit(-1);
    }
    /* Wait till threads are complete before main continues. */

    int *ret_value = NULL;
    pthread_join(thread1, (void**)(&ret_value));

    printf("最终的结果: %d \n",*ret_value);
    
    free(ret_value);

    return 0;
}

最终的结果: 35

#include <iostream>
#include <thread>

void print_hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建一个新线程并执行print_hello函数
    std::thread t(print_hello);

    // 等待线程执行完成
    t.join();

    return 0;
}

#include <iostream>
#include <thread>


void print_hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(&print_hello); // 使用函数指针定义线程
    t.join();
    return 0;
}

#include <iostream>
#include <thread>


int main() {
    std::thread t([]{
        std::cout << "Hello from thread!" << std::endl;
    }); // 使用Lambda表达式定义线程
    t.join();
    return 0;
}

#include <iostream>
#include <thread>


class MyClass {
    public:
        void print_hello() {
            std::cout << "Hello from thread!" << std::endl;
        }
};

int main() {
    MyClass obj;
    std::thread t(&MyClass::print_hello, &obj); // 使用成员函数定义线程
    t.join();
    return 0;
}

#include <iostream>
#include <thread>


class MyFunctor {
public:
    void operator()() {
        std::cout << "Hello from thread!" << std::endl;
    }
};

int main() {
    MyFunctor functor;
    std::thread t(functor); // 使用函数对象定义线程
    t.join();
    return 0;
}

#include <iostream>
#include <thread>

using namespace std;

void * add1_handler(void *arg)
{
    *(int*)arg = 56;
    
}

int main() {
    
    int value = 11;

    std::cout << "执行前value: " << value << std::endl;
    std::thread t(&add1_handler,&value);
    // 等待线程执行完成
    t.join();

    std::cout << "执行后value: " << value << std::endl;

    return 0;
}

执行前value: 11
执行后value: 56

#include <iostream>
#include <future>
#include <thread>

 
void func2(int x, int y,std::promise<int> &promiseObj) {
  promiseObj.set_value(x+y);
}
 
int main()
{
  //计算（a+b）/(x+y)
  //用三个线程，一个线程计算a+b，另一个线程计算x+y
  int a, b, x, y;
  a = 10, b = 8, x = 2, y = 4;
 
  int sum1, sum2;
  //声明一个类
  std::promise<int> promiseObj;
  //将future和promise关联
  std::future<int> futureObj = promiseObj.get_future();
  //模板传参的时候使用ref，否则传参失败
  std::thread t1(func2, a, b, ref(promiseObj));
  t1.join();
  //获取值
  sum1 = futureObj.get();
  std::cout << "sum1=" << sum1 << std::endl;
 
  //不能直接复用上面的future和promise
  std::promise<int> promiseObj2;
  std::future<int> futureObj2 = promiseObj2.get_future();
 
  std::thread t2(func2, x, y, ref(promiseObj2));
  t2.join();
  sum2 = futureObj2.get();
  std::cout << "sum2=" << sum2 << std::endl;
 
  std::cout << "sum1/sum2=" << sum1 / sum2 << std::endl;
   
  return 0;
}

sum1=18
sum2=6
sum1/sum2=3