同步的问题及解决方案

同步

同步的问题

当给狗狗食物的同时，狗狗又在吃，这会导致在运行过程中会出现食物的数据的错乱，有时候会多出数据，有时候会少出数据，这就让狗狗有时候会很吃亏，那么该如何解决呢？

实验体现

package multiThread2;

public class Animal{
    private String name;
    private int year;
    Animal(){}
    private int food;
    public Animal(String name,int year,int food){
        this.name = name;
        this.year = year;
        this.food = food;
    }

    @Override
    public String toString() {
        return "姓名："+ name + "，年龄：" + year + "，来干饭了，还剩"+ food + "个食物";
    }

    public String getName() {
        return name;
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getFood() {
        return food;
    }

    public void setFood(int food) {
        this.food = food;
    }
    public void eatFood(){
        this.food--;
    }
    public void addFood(){
        this.food++;
    }
}

package multiThread2;

public class main {
    public static void main(String[] args) throws InterruptedException {
        Animal a2 = new Animal("旺财",3,200);
        System.out.println(a2.getName()+"原本的食物有"+a2.getFood());
        Thread[] addThread = new Thread[200];
        Thread[] reduceThread = new Thread[200];
//        n个线程增加狗的食物
        for (int i = 0; i < 200; i++) {
            Thread t = new Thread(() -> {
                a2.addFood();
                try{
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
            });
            t.start();
            addThread[i]=t;
        }
//        n个线程减少狗的食物
        for (int i = 0; i < 200; i++) {
            Thread t = new Thread(() ->{
                a2.eatFood();
                try {
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
            });
            t.start();
            reduceThread[i]=t;
        }
//        等待所有增加线程的结束
        for(Thread t: addThread){
            try {
                t.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        for (Thread t: reduceThread) {
            try {
                t.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        System.out.println(a2.getName()+"的食物变成了"+a2.getFood()+"个");
    }
}

同步出现问题的原因

增加食物和减少食物是同时发生的事件，这会导致在增加食物的反应时间的同时，减少食物的情况正在发生，来不及增加食物，这会导致食物结果减少，反之亦然。

解决方案

在增加食物这一个线程发生的过程中，其他线程禁止访问

1. 增加线程获取到食物数据，并进行运算
2. 在运算期间，减少线程试图来访问食物数据，但是不被允许
3. 在增加线程执行完毕之后，减少线程才能访问食物数据
4. 减少数据运行完毕

synchronized 同步对象概念

Object someObject = new Object();
synchronized(someObject){
}

• synchronized表示当前线程，独占对象someObject当前线程独占 了对象someObject，如果有其他线程试图占有对象someObject，就会等待，直到当前线程释放对someObject的占用。
• someObject 又叫同步对象，所有的对象，都可以作为同步对象
  为了达到同步的效果，必须使用同一个同步对象
• 释放同步对象的方式： synchronized 块自然结束，或者有异常抛出

package multiThread2;

public class Animal{
    private String name;
    private int year;
    Animal(){}
    private int food;
    public Animal(String name,int year,int food){
        this.name = name;
        this.year = year;
        this.food = food;
    }

    @Override
    public String toString() {
        return "姓名："+ name + "，年龄：" + year + "，来干饭了，还剩"+ food + "个食物";
    }

    public String getName() {
        return name;
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getFood() {
        return food;
    }

    public void setFood(int food) {
        this.food = food;
    }
    public void eatFood(){
        this.food--;
    }
    public void addFood(){
        this.food++;
    }
}

package multiThread2;

public class main {
    public static void main(String[] args) throws InterruptedException {
        Animal a2 = new Animal("旺财", 3, 200);
        System.out.println(a2.getName() + "原本的食物有" + a2.getFood());
        Thread[] addThread = new Thread[200];
        Thread[] reduceThread = new Thread[200];
        Object someObject = new Object();
//        n个线程增加狗的食物
//        for (int i = 0; i < 5; i++) {
        Thread t1 = new Thread(() -> {
            a2.addFood();
            try {
                System.out.println("t1试图进行");
                System.out.println("t1试图占有someObject对象");
                synchronized (someObject) {
                    System.out.println("t1占有someObject对象");
                    Thread.sleep(100);
                    System.out.println("t1释放someObject对象");
                }
                System.out.println("t1结束");
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t1.start();
//            addThread[i] = t;
//        }
//        n个线程减少狗的食物
//        for (int i = 0; i < 5; i++) {
        Thread t2 = new Thread(() -> {
            a2.eatFood();
            try {
                System.out.println("t2试图进行");
                System.out.println("t2试图占有someObject对象");
                synchronized (someObject) {
                    System.out.println("t2占有someObject对象");
                    Thread.sleep(100);
                    System.out.println("t2释放someObject对象");
                }
                System.out.println("t2结束");
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t2.start();
//            reduceThread[i]=t;
//        }
//        等待所有增加线程的结束
//        for(Thread t: addThread){
//            try {
//                t.join();
//            }catch (Exception e){
//                e.printStackTrace();
//            }
//        }
//        for (Thread t: reduceThread) {
//            try {
//                t.join();
//            }catch (Exception e){
//                e.printStackTrace();
//            }
//        }
//        System.out.println(a2.getName()+"的食物变成了"+a2.getFood()+"个");
    }
}

在方法前加一个修饰符synchronized

此时主函数可以不用加入synchronized

线程安全的类

如果一个类，它的方法都是有synchronized修饰的，那么该类就是线程安全的类