通过 N 个线程顺序循环打印从 0 至 100

Posted 2023-03-30 zhoudelun

using System;
using System.Threading;

class PrintThread

    private int id;
    private int totalThreads;
    private int startNum;
    private int endNum;
    private ManualResetEvent waitEvent;

    public PrintThread(int id, int totalThreads, int startNum, int endNum, ManualResetEvent waitEvent)
    
        this.id = id;
        this.totalThreads = totalThreads;
        this.startNum = startNum;
        this.endNum = endNum;
        this.waitEvent = waitEvent;
    

    public void Run()
    
        for (int i = startNum; i <= endNum; i += totalThreads)
        
            Console.WriteLine("Thread 0: 1", id, i);
            Thread.Sleep(100);
        

        waitEvent.Set();  // 通知主线程该线程已完成打印任务
    


class Program

    static void Main(string[] args)
    
        int n = 3;  // N 个线程
        int totalNums = 101;  // 打印从 0 至 100
        ManualResetEvent[] events = new ManualResetEvent[n];

        for (int i = 0; i < n; i++)
        
            events[i] = new ManualResetEvent(false);
            PrintThread thread = new PrintThread(i, n, i, totalNums - 1, events[i]);
            Thread t = new Thread(thread.Run);
            t.Start();
        

        // 等待所有线程完成打印任务
        WaitHandle.WaitAll(events);

        Console.WriteLine("All threads have finished printing.");
    

这段代码中，我们创建了 N 个线程，每个线程负责打印从 0 至 100 中特定的一部分数字。在每个线程的Run方法中，我们使用步长为 N 的方式遍历该线程负责的数字，并输出该数字。为了模拟真实的场景，我们在输出数字之后让线程休眠 100 毫秒。

在主程序中，我们创建了 N 个PrintThread对象，并分别给它们分配不同的数字范围。然后，我们启动这 N 个线程，并使用WaitHandle.WaitAll方法等待它们完成打印任务。最终输出的结果是从 0 至 100 的数字，按顺序依次被打印出来。

public class PrintThread implements Runnable 
    private int threadId;
    private int threadNum;
    private int count;
    private Object lock;

    public PrintThread(int threadId, int threadNum, int count, Object lock) 
        this.threadId = threadId;
        this.threadNum = threadNum;
        this.count = count;
        this.lock = lock;
    

    public void run() 
        int i = 0;
        while (true) 
            synchronized (lock) 
                while (i % threadNum != threadId) 
                    try 
                        lock.wait();
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                

                if (i > count) 
                    break;
                

                System.out.println("Thread " + threadId + ": " + i);
                i++;

                lock.notifyAll();
            
        
    


public class Main 
    public static void main(String[] args) 
        int threadNum = 5;
        int count = 100;
        Object lock = new Object();

        for (int i = 0; i < threadNum; i++) 
            PrintThread thread = new PrintThread(i, threadNum, count, lock);
            new Thread(thread).start();
        
    

在这段代码中，我们创建了一个PrintThread类来表示每个线程。构造函数接收线程的 ID、线程数、计数值和锁对象。在run()方法中，我们使用synchronized关键字来确保线程之间的同步。线程会循环打印数值，当数值超过给定的计数值时，线程会退出循环。在每次打印完数值后，线程会通知所有等待该锁的线程继续执行，以便下一个线程打印数值。

在主程序中，我们创建了一个锁对象和多个PrintThread对象。然后，我们启动每个线程。在每个线程中，线程会根据它们的 ID 和线程数来计算它们需要打印的数值。在打印完数值后，线程会通知下一个线程继续执行，直到所有线程完成任务并退出。