一个线程进行如下运算1+2+3+4+….+200,而另一个线程则每隔一个随机产生的时间(0-100毫秒)读取依次第一个线程的当前运算结果并输出。

这个问题需要用到多线程编程。你可以使用Python中的threading模块来实现。代码如下：

import threading
import time
import random

# 定义一个全局变量用于存储运算结果
result = 0

# 定义一个函数用于计算1+2+3+...+200
def calculate():
    global result
    for i in range(1, 201):
        result += i

# 定义一个函数用于每隔一个随机时间读取并输出结果
def print_result():
    global result
    while True:
        time.sleep(random.randint(0, 100) / 1000) # 随机等待一段时间
        print(result)

# 创建两个线程并启动
t1 = threading.Thread(target=calculate)
t2 = threading.Thread(target=print_result)
t1.start()
t2.start()

在代码中，我们定义了一个全局变量`result`用于存储运算结果，然后创建了两个函数`calculate`和`print_result`分别用于计算结果和输出结果。在`print_result`函数中，我们使用了`time.sleep`函数来实现随机等待一段时间。最后，我们创建了两个线程并启动，分别执行这两个函数。

相关问题

用Java语言实现一个线程进行如下运算1+2+3+4+….+200,而另一个线程则每隔一个随机产生的时间(0-100毫秒)读取依次第一个线程的当前运算结果并输出。

以下是用Java语言实现的代码示例：

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        SumThread sumThread = new SumThread();
        PrintThread printThread = new PrintThread(sumThread);

        sumThread.start();
        printThread.start();

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

class SumThread extends Thread {
    private int sum;
    private Object lock = new Object();

    public void run() {
        for (int i = 1; i <= 200; i++) {
            synchronized (lock) {
                sum += i;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public int getSum() {
        synchronized (lock) {
            return sum;
        }
    }
}

class PrintThread extends Thread {
    private SumThread sumThread;
    private Random random = new Random();

    public PrintThread(SumThread sumThread) {
        this.sumThread = sumThread;
    }

    public void run() {
        while (true) {
            try {
                Thread.sleep(random.nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("current sum: " + sumThread.getSum());
        }
    }
}

代码中，`SumThread`代表计算和的线程，`PrintThread`代表输出结果的线程。`SumThread`使用`synchronized`关键字和一个锁来保证在计算和的过程中，任何时候只有一个线程能够修改`sum`的值。`PrintThread`每隔一个随机时间间隔读取`SumThread`的计算结果并输出。

在主函数中，我们启动两个线程并等待它们完成运行。当`SumThread`完成计算后，`join()`函数会等待`PrintThread`完成输出，然后整个程序结束。

c语言5个线程实现1+2+3+。。。1000000。

以下是使用5个线程实现1到1000000的代码：

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

#define NUM_THREADS 5
#define TARGET 1000000

int sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *calculate_sum(void *thread_id) {
    int id = *(int *)thread_id;
    int start = (id-1)*(TARGET/NUM_THREADS) + 1;
    int end = id*(TARGET/NUM_THREADS);
    int local_sum = 0;

    for (int i = start; i <= end; i++) {
        local_sum += i;
    }

    pthread_mutex_lock(&mutex);
    sum += local_sum;
    pthread_mutex_unlock(&mutex);
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    int thread_ids[NUM_THREADS];

    for (int i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i+1;
        pthread_create(&threads[i], NULL, calculate_sum, &thread_ids[i]);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("The sum of 1 to %d is %d\n", TARGET, sum);

    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);
}

这个程序使用5个线程，每个线程计算1到TARGET（1000000）之间的一部分数字的总和，然后将局部总和加到全局总和中。由于多个线程同时更新全局总和可能会导致竞争条件，因此使用互斥锁来保护全局总和。最后，主线程等待所有线程完成后打印总和。