用两个线程，一个输出字母，一个输出数字，交替输出 1A2B3C4D...26Z

Posted 2023-03-30 zhoudelun

using System;
using System.Threading;

class PrintThread

    private string name;
    private AutoResetEvent waitEvent;
    private AutoResetEvent nextEvent;
    private int start;
    private int end;

    public PrintThread(string name, AutoResetEvent waitEvent, AutoResetEvent nextEvent, int start, int end)
    
        this.name = name;
        this.waitEvent = waitEvent;
        this.nextEvent = nextEvent;
        this.start = start;
        this.end = end;
    

    public void Run()
    
        for (int i = start; i <= end; i += 2)
        
            waitEvent.WaitOne();  // 等待前一个线程的信号

            if (name == "NumberThread")
            
                Console.Write("0", i);
            
            else if (name == "LetterThread")
            
                Console.Write("0", (char)(i + 64));
            

            nextEvent.Set();  // 通知下一个线程继续执行
        
    


class Program

    static void Main(string[] args)
    
        AutoResetEvent eventNumber = new AutoResetEvent(false);
        AutoResetEvent eventLetter = new AutoResetEvent(false);

        PrintThread threadNumber = new PrintThread("NumberThread", eventLetter, eventNumber, 1, 26);
        PrintThread threadLetter = new PrintThread("LetterThread", eventNumber, eventLetter, 2, 27);

        Thread tNumber = new Thread(threadNumber.Run);
        Thread tLetter = new Thread(threadLetter.Run);

        tNumber.Start();
        tLetter.Start();

        // 启动第一个线程
        eventLetter.Set();

        // 等待所有线程完成打印任务
        tNumber.Join();
        tLetter.Join();

        Console.WriteLine("\\nAll threads have finished printing.");
    

在这段代码中，我们创建了两个PrintThread对象，分别表示数字线程和字母线程。每个线程负责输出一定范围内的数字或字母，并在输出完成之后等待另一个线程的信号。我们使用AutoResetEvent来实现线程之间的信号传递。

在主程序中，我们创建了两个AutoResetEvent对象，并将它们分别传递给数字线程和字母线程。然后，我们启动这两个线程，并使用第一个AutoResetEvent对象启动第一轮打印任务。在每轮打印任务结束之后，我们使用另一个AutoResetEvent对象通知另一个线程继续执行。最终，我们等待所有线程完成打印任务，并输出一条完成消息。

import java.util.concurrent.Semaphore;

public class PrintThread implements Runnable 
    private String name;
    private Semaphore current;
    private Semaphore next;
    private int start;
    private int end;

    public PrintThread(String name, Semaphore current, Semaphore next, int start, int end) 
        this.name = name;
        this.current = current;
        this.next = next;
        this.start = start;
        this.end = end;
    

    public void run() 
        for (int i = start; i <= end; i += 2) 
            try 
                current.acquire(); // 等待前一个线程的信号
             catch (InterruptedException e) 
                e.printStackTrace();
            

            if (name.equals("NumberThread")) 
                System.out.print(i);
             else if (name.equals("LetterThread")) 
                System.out.print((char) (i + 64));
            

            next.release(); // 通知下一个线程继续执行
        
    


public class Main 
    public static void main(String[] args) 
        Semaphore semaphoreNumber = new Semaphore(0);
        Semaphore semaphoreLetter = new Semaphore(1);

        PrintThread threadNumber = new PrintThread("NumberThread", semaphoreLetter, semaphoreNumber, 1, 26);
        PrintThread threadLetter = new PrintThread("LetterThread", semaphoreNumber, semaphoreLetter, 2, 27);

        Thread tNumber = new Thread(threadNumber);
        Thread tLetter = new Thread(threadLetter);

        tNumber.start();
        tLetter.start();

        // 启动第一个线程
        semaphoreLetter.release();

        // 等待所有线程完成打印任务
        try 
            tNumber.join();
            tLetter.join();
         catch (InterruptedException e) 
            e.printStackTrace();
        

        System.out.println("\\nAll threads have finished printing.");
    

在这段代码中，我们创建了两个PrintThread对象，分别表示数字线程和字母线程。每个线程负责输出一定范围内的数字或字母，并在输出完成之后等待另一个线程的信号。我们使用Semaphore来实现线程之间的信号传递。

在主程序中，我们创建了两个Semaphore对象，并将它们分别传递给数字线程和字母线程。然后，我们启动这两个线程，并使用第一个Semaphore对象启动第一轮打印任务。在每轮打印任务结束之后，我们使用另一个Semaphore对象通知另一个线程继续执行。最终，我们等待所有线程完成打印任务，并输出一条完成消息。