线程互斥与同步案例

约定不等于承诺〃 2022-06-16 05:44 243阅读 0赞

一共有100个盒子，每个盒子中有一定数量的能量，每个线程持有一个盒子，向其他盒子中注入能量，实现能量守恒。

public class EnergySystem {
        //能量盒子，能量存储的地方
        private final double[] energyBoxes;
        private final Object lockObj=new Object();
        /**
         * @param n 能量盒子的数量
         * @param initialEnergy 每个能量盒子初始含有的能量
         */
        public EnergySystem(int n,double initialEnergy){
            energyBoxes=new double[n];
            for(int i=0;i<energyBoxes.length;i++)
                energyBoxes[i]=initialEnergy;
        }
        /**
         * 能量转移，从一个盒子到另一个盒子
         */
        public void transfer(int from,int to,double amount){
            synchronized (lockObj){
                while(energyBoxes[from]<amount)
                    try {
                        lockObj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                System.out.print(Thread.currentThread().getName());
                energyBoxes[from]-=amount;
                System.out.printf("从%d转移%10.2f单位能量到%d",from,amount,to);
                energyBoxes[to]+=amount;
                System.out.printf("能量总和：%10.2f%n",getTotalEnergies());
                //往其他盒子中加过能量，可能就造成某个等待的线程不需要等待
                //因为不知道应该唤醒哪个线程，所以唤醒所有的线程
                lockObj.notifyAll();
            }
        }
        /**
         * 获取能量世界的能量总和
         */
        public double getTotalEnergies(){
            double sum=0;
            for(double amount:energyBoxes)
                sum+=amount;
            return sum;
        }
        /**
         * 返回能量盒子的长度
         */
        public int getBoxAmount(){
            return energyBoxes.length;
        }
    }

public class EnergyTransferTask implements Runnable{
        //共享的能量世界
        private EnergySystem energySystem;
        //能量转移的源能量盒子下标
        private int fromBox;
        //单次能量转移最大单元
        private double maxAmount;
        //最大休眠时间
        private int DELAY=10;
        public EnergyTransferTask(EnergySystem energySystem,int from,double max){
            this.energySystem=energySystem;
            this.fromBox=from;
            this.maxAmount=max;
        }
        @Override
        public void run() {
            try {
                while(true){
                    int toBox=(int)(energySystem.getBoxAmount()* Math.random());
                    double amount=maxAmount*Math.random();
                    energySystem.transfer(fromBox,toBox,amount);
                    Thread.sleep((int)(DELAY*Math.random()));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public class EnergySystemTest {
        //将要构建的能量世界中能量盒子数量
        public static final int BOX_AMOUNT=100;
        //每个盒子初始能量
        public static final double INITIAL_ENERGY=1000;
        public static void main(String[] args){
            EnergySystem eng=new EnergySystem(BOX_AMOUNT,INITIAL_ENERGY);
            for(int i=0;i<BOX_AMOUNT;i++){
                EnergyTransferTask task=new
                        EnergyTransferTask(eng,i,INITIAL_ENERGY);
                Thread t=new Thread(task,"TransferThread_"+i);
                t.start();
            }
        }
    }