实战多线程之synchronized

案例说明：

两个线程同时操作一个数，一个线程操作加，另一个线程操作减：

package com.My.Schedule_test.demo.ConPro;

public class zongjie{

    static int r = 5;//被操作数
    static final int Max = 5;//操作数的最大值
    static Boolean order = false;//状态值：false代表递减，true代表递增

    private String name;
    public zongjie(String name){
//        super(name);
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public void incre(){
        synchronized (this){
            while(r >= Max || !order){//当操作数到达最大值或者还是递减状态的情况下
                order = false;
                System.out.println("太大了，需要递减！");
                this.notifyAll();//唤醒其余线程

                try{
                    this.wait();//进入等待
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }

//            System.out.println("开始递增");
            r += 1;


            System.out.println(Thread.currentThread().getName() + "开始递增-->r=" + r);

        }
    }

public void reduce(){
        synchronized (this){
            while(r <= 0 || order){//当操作数满足最小值或处于递增状态时
                order = true;
                System.out.println("太小了， 需要递增！");
                this.notifyAll();
                try {
                    this.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            r -= 1;

            System.out.println(Thread.currentThread().getName() + "开始递减-->r=" + r);
        }
    }

上述就是操作对象的代码，其中的代码说明已经通过注释进行讲解。

接下来就是实现线程代码继承Thread。一个自增一个自减。

package com.My.Schedule_test.demo.ConPro;

public class Operationadd extends Thread {

    zongjie z;

    private String name;
    public Operationadd(String name, zongjie z){
        this.z = z;
        this.name = name;
    }



    @Override
    public void run(){

        while(true){
            z.incre();
            try{
                sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

    }

}

package com.My.Schedule_test.demo.ConPro;

public class OperationReduce extends Thread {

    zongjie z;
    private String name;
    public OperationReduce(String name, zongjie z){
        this.name = name;
        this.z = z;
    }



    @Override
    public void run(){
        while(true){
            z.reduce();
            try{
                sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

}

这样就实现了，自增自减，结果表现为：

Thread-1开始递减-->r=3
Thread-1开始递减-->r=2
Thread-1开始递减-->r=1
Thread-1开始递减-->r=0
太小了， 需要递增！
Thread-0开始递增-->r=1
Thread-0开始递增-->r=2
Thread-0开始递增-->r=3
Thread-0开始递增-->r=4
Thread-0开始递增-->r=5
太大了，需要递减！
Thread-1开始递减-->r=4
Thread-1开始递减-->r=3
Thread-1开始递减-->r=2
Thread-1开始递减-->r=1
Thread-1开始递减-->r=0
太小了， 需要递增！
Thread-0开始递增-->r=1
Thread-0开始递增-->r=2
Thread-0开始递增-->r=3
Thread-0开始递增-->r=4
Thread-0开始递增-->r=5
太大了，需要递减！