Java--多线程:一个变量初始值100，一个任务对它进行50次自增操作，而另外一个任务对它进行50次自减操作。

题目：一个变量初始值100，一个任务对它进行50次自增操作，而另外一个任务对它进行50次自减操作。

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

代码：

public class Day61 {
    public static void main(String[] args) {
        /**
         * n：自加次数
         * m：自减次数
         * num：变量初始值
         */
        int n = 50, m = 50;
        int num = 100;
        new Day61().init(num, n, m);
    }

    public void init(final int num, final int n, final int m) {
        final PrintNum printNum = new PrintNum(num);

        /**
         * 输出最终值
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                printNum.print("最终值");
            }
        }).start();

        /**
         * 自减m次
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < m; i++) {
                    printNum.minus();
                }
                printNum.changePrintFlag();
            }
        }).start();

        /**
         * 自加m次
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < n; i++) {
                    printNum.add();
                }
                printNum.changeOptionFlag();
            }
        }).start();
    }
}

class PrintNum {
    /**
     * printFlag:初始化打印标志 false：不能打印
     * optionFlag:初始化操作标志  false为add，true为minus
     */
    private boolean printFlag = false;
    private boolean optionFlag = true;
    int num1;

    public PrintNum(int num) {
        num1 = num;
    }

    public synchronized void print(String str) {
        while (!printFlag) {
            try {
                //调用父类Object的native方法wait()
                //wait()让线程挂起，直到通知到它继续执行！挂起的线程会存放到等待队列中，按照wait的先后顺序存放。
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(str + num1);
        //notify()通知等待队列中的第一个线程
        this.notify();
        printFlag = !printFlag;
    }

    public synchronized void add() {
        while (!optionFlag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num1++;
        System.out.println("自加：" + num1);
        this.notify();
    }

    public synchronized void minus() {
        while (optionFlag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num1--;
        System.out.println("自减：" + num1);
        this.notify();
    }

    public void changePrintFlag() {
        printFlag = !printFlag;
    }

    public void changeOptionFlag() {
        optionFlag = !optionFlag;
    }
}