有三个线程ID分别是A、B、C,用多线编程实现，在屏幕上循环打印10次ABCABC…

class Worker implements Runnable{  
   
    /** 全局的一个信息，用来确定是哪个线程在工作 */
    private static int count = 0;  
      
    /** 线程的标志 */
    private int id;  
   
    /** 线程已工作次数 */
    private int pCount;  
      
    public Worker(int id){  
        this.id = id;  
    }  
      
    public void run() {  
        synchronized ("lock") {  
            for (;;) {  
                if(count%3==id){  
                    System.out.print(Thread.currentThread().getName());  
                    count++;  
                    pCount++;  
                    "lock".notifyAll();  
                    if(pCount==10)  
                        break;  
                }else{  
                    try {  
                        "lock".wait();  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
    }  
} 

    public static void main(String[] args)
    {
       
        new Thread(new Worker(0),"A").start();  
        new Thread(new Worker(1),"B").start();  
        new Thread(new Worker(2),"C").start(); 
    }

评论

2 楼 badhorse 2010-08-03  

前面的代码有个多线程方面的bug. 粗体部分是修改后的代码。

/**
 * 若干个LinkedThread线程可以依次串联起来，形成一条链（或一个环）,
 * 这条链（或环）的特点是：只有当上游线程执行完任务之后，下游线程才开始执行。这类似于接力赛跑的情形
 * ，每个LinkedThread线程相当于一个运动员，某个运动员跑完当前赛段后，就把接力棒交给下一个运动员。
 * 
 * @author Yubing Ma
 * 
 */
public class LinkedThread extends Thread {
	private LinkedThread previousThread;

	public void setPreviousThread(LinkedThread previousThread) {
		this.previousThread = previousThread;
	}

	public LinkedThread(LinkedThread previousThread, String msgToPrint) {
		this.previousThread = previousThread;
		this.msgToPrint = msgToPrint;
	}

	// 指示本线程是否已经完成当前任务。可以将此变量想象成一个接力棒。
	private boolean isFinished;

	private String msgToPrint;

	private static final int roundCount = 1000; // 重复执行任务的次数，可想象为接力赛跑的圈数

	public void run() {
		try {
			for (int i = 0; i < roundCount; i++) {
				waitPreviousThreadToFinish();
				doSomething();
				setFinishedFlag();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void waitPreviousThreadToFinish() throws InterruptedException {
		[b]synchronized (previousThread) {
			while (!previousThread.isFinished) {
				previousThread.wait();
			}
		}[/b]

		previousThread.isFinished = false;
	}

	/**
	 * 设置本线程为“任务已完成”状态，这将触发下游线程的执行。
	 */
	private void setFinishedFlag() {
		synchronized (this) {
			isFinished = true;
			this.notifyAll();
		}
	}

	private void doSomething() throws InterruptedException {
		System.out.print(msgToPrint);
	}

	public static void main(String[] args) throws InterruptedException {
		// 创建若干个线程，这些线程被串联成一个有向环，只有当上游线程执行完成之后，下游线程才会执行
		LinkedThread threadA = new LinkedThread(null, "A");
		LinkedThread threadB = new LinkedThread(threadA, "B");
		LinkedThread threadC = new LinkedThread(threadB, "C ");
		threadA.setPreviousThread(threadC); // 线程C成为A的上游，这样就形成一个封闭的环

		threadA.start();
		threadB.start();
		threadC.start();
		threadC.setFinishedFlag(); // 设置线程C为“已完成”状态，这将触发下游线程（线程A）开始执行
	}
}

1 楼 badhorse 2010-08-03  

/**
 * 若干个LinkedThread线程可以依次串联起来，形成一条链（或一个环）,
 * 这条链（或环）的特点是：只有当上游线程执行完任务之后，下游线程才开始执行。这类似于接力赛跑的情形
 * ，每个LinkedThread线程相当于一个运动员，某个运动员跑完当前赛段后，就把接力棒交给下一个运动员。
 * 
 * @author Yubing Ma
 * 
 */
public class LinkedThread extends Thread {
	private LinkedThread previousThread;

	public void setPreviousThread(LinkedThread previousThread) {
		this.previousThread = previousThread;
	}

	public LinkedThread(LinkedThread previousThread, String msgToPrint) {
		this.previousThread = previousThread;
		this.msgToPrint = msgToPrint;
	}

	// 指示本线程是否已经完成当前任务。可以将此变量想象成一个接力棒。
	private boolean isFinished;

	private String msgToPrint;

	private static final int roundCount = 10; // 重复执行任务的次数，可想象为接力赛跑的圈数

	public void run() {
		try {
			for (int i = 0; i < roundCount; i++) {
				waitPreviousThreadToFinish();
				doSomething();
				setFinishedFlag();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void waitPreviousThreadToFinish() throws InterruptedException {
		while (!previousThread.isFinished) {
			synchronized (previousThread) {
				previousThread.wait();
			}
		}

		previousThread.isFinished = false;
	}

	private void doSomething() throws InterruptedException {
		System.out.println(msgToPrint);
	}

	/**
	 * 设置本线程为“任务已完成”状态，这将触发下游线程的执行。
	 */
	private void setFinishedFlag() {
		synchronized (this) {
			isFinished = true;
			this.notifyAll();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		// 创建若干个线程，这些线程被串联成一个有向环，只有当上游线程执行完成之后，下游线程才会执行
		LinkedThread threadA = new LinkedThread(null, "A");
		LinkedThread threadB = new LinkedThread(threadA, "B");
		LinkedThread threadC = new LinkedThread(threadB, "C");
		threadA.setPreviousThread(threadC); // 线程C成为A的上游，这样就形成一个封闭的环

		threadA.start();
		threadB.start();
		threadC.start();
		threadC.setFinishedFlag(); // 设置线程C为“已完成”状态，这将触发下游线程（线程A）开始执行
	}
}

[*]
[b][/b]