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

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对象通知另一个线程继续执行。最终，我们等待所有线程完成打印任务，并输出一条完成消息。