多线程同步循环打印

            /**
            
 * 锁码：公共数据区
 * 码值：码值为A，表示应该由A线程来执行，B,C线程等待
 *      码值为B,C同理。
 
            */
            class
             LockCode{
    
            /**
            当前锁码码值，初始码值为A，表示最初由A线程运行
            */
            private
            char code=‘A‘;
    /**单例模式*/private LockCode(){
    }
    
    publicstatic LockCode newInstance(){
        returnnew LockCode();
    }
    /**
     * 循环设置锁码
     * 每一次调用，锁码按照A-B-C-A-...-的顺序循环往复
     */publicvoid setCode(){
        this.code=(char)(this.code+1);
        if(this.code==‘D‘)
            this.code=‘A‘;
    }
    /**
     * 得到锁码
     */publicchar getCode(){
        returnthis.code;
    }
}
/**
 * 完成打印工作的线程类
 */class PrintRunnable implements Runnable{
    /**需要打印的字符*/privatechar character=‘?‘;
    /**公共锁码*/private LockCode lockCode=null;
    
    PrintRunnable(char c,LockCode l){
        this.character=c;
        this.lockCode=l;
    }
    /**
     * 线程执行
     */publicvoid run() {
        int loopCount=1;
        while(loopCount<=10){
            synchronized(lockCode){//线程同步操作锁码try{
                    //如果当前运行的线程并不等于当前锁码的码值，则改线程等待
                    //比如当前运行线程是A，但是码值为B，则A线程等待。while(lockCode.getCode()!=this.character)
                        lockCode.wait();
                    //码值匹配成功，打印字符
                    System.out.print(this.character);
                    //循环10次记数
                    loopCount++;
                    //设置码值，让下一个线程可以运行                    lockCode.setCode();
                    //让其他所有等待线程激活                    lockCode.notifyAll();
                }catch(InterruptedException e){  
                    e.printStackTrace();  
                }  
            }
        }
    }
    
}
/**
 * 测试
 */publicclass ThreadLoopPrint {
    
    publicstaticvoid main(String[] args) {
        LockCode lockCode=LockCode.newInstance();//公共锁码
        Thread ta=new Thread(new PrintRunnable(‘A‘,lockCode));
        Thread tb=new Thread(new PrintRunnable(‘B‘,lockCode));
        Thread tc=new Thread(new PrintRunnable(‘C‘,lockCode));
        ta.start();
        tb.start();    
        tc.start();
    }
}

            /**
            
 *此代码和上面的代码有一个很大的相同点，就是都利用公共数据区中的数据变化来决定线程工作还是阻塞等待。公共数据区利用了类静态变量。因此代码简洁。
 *
 *
            @author
             jiangtao
 *@date 2010-2-27
 *
            @version
             1.0
 
            */
            public
            class MyThread extends Thread{

    publicstatic String[] NAMES = new String[] { "A", "B", "C" };

    publicstaticint POS = 0;

    privatestaticfinallong DURATION = 1000;
    
    privateint count = 10;

    public MyThread (String name) {
        this.setName(name);
    }

    @Override
    publicvoid run() {
        while (count > 0) {
            if (this.getName().equals(NAMES[POS])) {
                this.print();
                this.count--;
            }
            try {
                Thread.sleep(DURATION);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    privatesynchronizedvoid print() { //不要sync也可以，因为我们的if限制。
        System.out.print(this.getName());
        POS = (POS >= NAMES.length - 1 ? 0 : ++POS);
    }
    
    publicstaticvoid main(String[] args) {
        new MyThread ("A").start();
        new MyThread ("B").start();
        new MyThread ("C").start();
    }
}