如果我需要写一个多线程程序应该怎么做？三个线程，两个线程名为a和b，还有一个线程为c。三个线程交替打印100，如果计数到10的时候，由线程c来打印

要编写一个多线程程序，您需要遵循以下步骤：

1. 引入线程库：您需要引入适当的线程库，例如Java中的java.util.concurrent或C++中的pthread.h。

2. 创建线程：您需要创建线程，可以使用线程库中提供的函数来创建线程并指定线程函数。

3. 启动线程：一旦您创建了线程并指定了线程函数，您需要启动线程以开始执行线程函数。

4. 同步线程：如果您的线程需要互相同步，您需要使用锁或信号量等同步机制。

5. 终止线程：当线程完成其工作或您需要停止线程时，您需要终止线程。

下面是一个实现您描述的多线程程序的示例代码：

Java代码：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiThread {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Condition conditionC = lock.newCondition();
        int count = 0;
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                while (count < 100) {
                    lock.lock();
                    try {
                        if (count % 10 != 0 || count == 0) {
                            System.out.println("Thread A: " + count++);
                        } else {
                            conditionB.signal();
                            conditionA.await();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                while (count < 100) {
                    lock.lock();
                    try {
                        if (count % 10 != 0 || count == 0) {
                            System.out.println("Thread B: " + count++);
                        } else {
                            conditionC.signal();
                            conditionB.await();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        });
        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                while (count < 100) {
                    lock.lock();
                    try {
                        if (count % 10 == 0 && count != 0) {
                            System.out.println("Thread C: " + count++);
                            conditionA.signal();
                            conditionC.await();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        });
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

在这个例子中，我们使用了Java中的ReentrantLock和Condition来实现线程同步。我们创建了三个线程：Thread A，Thread B和Thread C。Thread A和Thread B交替打印数字，当计数到10的倍数时，Thread C来打印。

Python代码：

import threading

lock = threading.Lock()
conditionA = threading.Condition(lock)
conditionB = threading.Condition(lock)
conditionC = threading.Condition(lock)
count = 0

def thread_a():
    global count
    while count < 100:
        with lock:
            if count % 10 != 0 or count == 0:
                print("Thread A:", count)
                count += 1
            else:
                conditionB.notify()
                conditionA.wait()

def thread_b():
    global count
    while count < 100:
        with lock:
            if count % 10 != 0 or count == 0:
                print("Thread B:", count)
                count += 1
            else:
                conditionC.notify()
                conditionB.wait()

def thread_c():
    global count
    while count < 100:
        with lock:
            if count % 10 == 0 and count != 0:
                print("Thread C:", count)
                count += 1
                conditionA.notify()
                conditionC.wait()

threadA = threading.Thread(target=thread_a)
threadB = threading.Thread(target=thread_b)
threadC = threading.Thread(target=thread_c)
threadA.start()
threadB.start()
threadC.start()

在这个例子中，我们使用了Python中的threading库来实现多线程。我们创建了三个线程：Thread A，Thread B和Thread C。Thread A和Thread B交替打印数字，当计数到10的倍数时，Thread C来打印。我们使用了锁和条件变量来实现线程同步。