编程实现三个线程ABC，并让它们顺次打印ABC

#include<stdio.h>
#include<sys/types.h>
#include<semaphore.h>
#include<pthread.h>

sem_t sem_id1, sem_id2, sem_id3;

void* func1(void*);    //声明
void* func2(void*);
void* func3(void*);

int main(void) {
    sem_init(&sem_id1, 0, 1);    //活动
    sem_init(&sem_id2, 0, 0);
    sem_init(&sem_id3, 0, 0);

    pthread_t pthread_id1, pthread_id2, pthread_id3;
    pthread_create(&pthread_id1, NULL, func1, NULL);
    pthread_create(&pthread_id2, NULL, func2, NULL);
    pthread_create(&pthread_id3, NULL, func3, NULL);

    pthread_join(phread_id1, NULL);
    pthread_join(phread_id1, NULL);
    pthread_join(phread_id1, NULL);

    return 0;
}

void *func1 (void*) {
    sem_wait(sem_id1);
    printf("A\n");
    sem_post(sem_id2);
}
void *func2 (void*) {
    sem_wait(sem_id2);
    printf("B\n");
    sem_post(sem_id3);
}
void *func3 (void*) {
    sem_wait(sem_id3);
    printf("C\n");
    sem_post(sem_id1);
}

package ABC;

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

public class Main {

	private static final Lock lock=new ReentrantLock();
	private static final Condition isA=lock.newCondition();
	private static final Condition isB=lock.newCondition();
	private static final Condition isC=lock.newCondition();

	static class ThreadA extends Thread {

		@Override
		public void run() {
			while(true){
				lock.lock();
				System.out.println("A");
				isB.signal();
				try {
					isA.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				lock.unlock();
			}
		}

	}

	static class ThreadB extends Thread {

		@Override
		public void run() {
			while(true){
				lock.lock();
				System.out.println("B");
				isC.signal();
				try {
					isB.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				lock.unlock();
			}
		}
	}

	static class ThreadC extends Thread {

		@Override
		public void run() {
			while(true){
				lock.lock();
				System.out.println("C");
				isA.signal();
				try {
					isC.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				lock.unlock();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		
		ThreadA a=new ThreadA();
		ThreadB b=new ThreadB();
		ThreadC c=new ThreadC();
		
		a.join();
		b.join();
		c.join();
		
		a.start();
		b.start();
		c.start();
		
	}
}

lockb=threading.Lock()
lockc=threading.Lock()

def printa():
    print 'A'
    lockb.release()

def printb():
    lockb.acquire()
    print 'B'
    lockc.release()
    lockb.release()

def printc():
    lockc.acquire()
    print 'C'
    lockc.release()


def run():
    lockb.acquire()
    lockc.acquire()
    tc = threading.Thread(target=printc)
    tc.start()
    tb = threading.Thread(target=printb)
    tb.start()
    ta = threading.Thread(target=printa)
    ta.start()

if __name__ == '__main__':
    run()