用多线程的方式实现对一个数随机自增N次， 随机自减M次，最后打印出这个数字 （不能用原子操作类AtomicInteger）

            最近一直在学多线程的东西,今天在网看到看到了这样的一个题目:

用多线程的方式实现对一个数随机自增N次， 随机自减M次，最后打印出这个数字  （不能用原子操作类AtomicInteger）.

写了这段代码,望大家指点.

代码:

public class MultiThreadRandomNumTest {
    public static void main(String[] args) {
        int n = 5000;   //自加次数
        int m = 1000;   //自减次数
        int randNo = (int) (Math.random()*1000);    //随机数
//        Random rand = new Random();
//        int randNo = rand.nextInt(1000);
        new MultiThreadRandomNumTest().init(randNo,n,m);
    }
    
    public void init(final int randNo,final int n,final int m){
        final RandomNum randomnum = new RandomNum(randNo);
        new Thread(new Runnable(){  //输出最终值
            public void run() {
                randomnum.print("最终值");
            }
                
        }).start();
        new Thread(new Runnable() {   //自减M次
            public void run() {
                for(int i=0;i<m;i++){
                    randomnum.minus();
                }
                randomnum.changePrintflag();
            }
        }).start();
        new Thread(new Runnable() {  //自加N次
            public void run() {
                for(int i=0;i<n;i++){
                    randomnum.add();
                }
                randomnum.changeOptionFlag();
            }
        }).start();
        
    }
    
    public class RandomNum{
        private boolean printFlag = false;  //初始化打印标志 false :不能打印
        private boolean optionFlag = true;   //操作标志 false 为add ture为minus
        int randNO;
        public RandomNum(int randNo){
            randNO = randNo;
        }
        
        public synchronized void print(String str){  
            while(!printFlag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(str+randNO);
            this.notify();
            printFlag = !printFlag;
        }
        
        public synchronized void add(){
            while(!optionFlag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            randNO++;
            System.out.println("自加:"+randNO);
            this.notify();
        }
        public synchronized void minus(){
            while(optionFlag){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            randNO--;
            System.out.println("自减:"+randNO);
            this.notify();
        }
        public  void changePrintflag(){
            printFlag = !printFlag;
        }
        
        public void changeOptionFlag(){
            optionFlag = !optionFlag;
        }
    }

}

题目的思路:将操作的共同数据,同步锁,共同方法放到同一个类中,再由线程调用这个类对象.