设计一个生产电脑和搬运电脑的类，要求生产一台电脑就搬走一台电脑，如果新的电脑没有生产出来，则搬运工等待 ，如果生产的电脑没被搬走则要等搬走后再继续生产。并输出生产电脑的台数

 1.首先设计一个电脑类Computer,里面有两个方法分别用于生产电脑和搬运电脑

/**
 * @ClassName: Computer
 * @Description: 设计一个生产电脑和搬运电脑的类，要求生产一台电脑就搬走一台电脑，如果新的电脑没有生产出来，则搬运工等待；
 * 如果生产的电脑没被搬走则要等搬走后再继续生产。然后输出生产的电脑的台数
 * @Author: 
 * @Date: 2019/6/5
 */
public class Computer {

    private String name;
    private int count = 0;
    private boolean flag = false;

    public String getName() {
        return name;
    }

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

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    /*
     * @Author 
     * @Description  生产电脑的方法
     * @Date 2019/6/5
     * @Param [name]
     * @return void
     **/
    public synchronized void proComputer(String name){
        if(flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name;
        this.count = count++;
        flag = true;
        System.out.println("生产了一台电脑："+this.name);
        System.out.println("目前共生产了"+(this.count+1)+"台");
        notify();
    }
    
    /*
     * @Author 
     * @Description  搬运电脑的方法
     * @Date 2019/6/5
     * @Param []
     * @return String[]
     **/
    public synchronized String[] conComputer(){
        if(!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag = false;
        notify();
        String[] str = new String[2];
        str[0] = this.name;
        str[1] = this.count+"";
        return str;
    }

}

2.使用多线程实现生产和搬运的效果

/**
 * @ClassName: ProComputer
 * @Description: 生产电脑
 * @Author: 
 * @Date: 2019/6/5
 */
public class ProComputer implements Runnable {

    Computer q2 = null;

    public ProComputer(Computer q2) {
        this.q2 = q2;
    }

    @Override
    public void run() {
        try {
            int count = 0;
            for (int i = 0; i < 20 ; i++) {
                if(i % 2 == 0){
                    q2.proComputer("联想"+i);
                }else{
                    q2.proComputer("神州"+i);
                }

                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @ClassName: ConComputer
 * @Description: 搬运电脑
 * @Author: 
 * @Date: 2019/6/5
 */
public class ConComputer implements Runnable {

    Computer q2 = null;

    public ConComputer(Computer q2) {
        this.q2 = q2;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20 ; i++) {
            String[] computer = q2.conComputer();
            System.out.println("搬走了"+computer[0]);
        }
    }
}

3.测试功能

public class ComputerMainTest {

    public static void main(String[] args) {
        Computer q2 = new Computer();
        ProComputer pc = new ProComputer(q2);
        ConComputer cc = new ConComputer(q2);
        Thread tp = new Thread(pc);
        Thread tc = new Thread(cc);
        tp.start();
        tc.start();
    }
}

测试结果

生产了一台电脑：联想0
目前共生产了1台
搬走了联想0
生产了一台电脑：神州1
目前共生产了1台
搬走了神州1
生产了一台电脑：联想2
目前共生产了1台
搬走了联想2
生产了一台电脑：神州3
目前共生产了1台
搬走了神州3
生产了一台电脑：联想4
目前共生产了1台
搬走了联想4
生产了一台电脑：神州5
目前共生产了1台
搬走了神州5
生产了一台电脑：联想6
目前共生产了1台
搬走了联想6
生产了一台电脑：神州7
目前共生产了1台
搬走了神州7
生产了一台电脑：联想8
目前共生产了1台
搬走了联想8
生产了一台电脑：神州9
目前共生产了1台
搬走了神州9
生产了一台电脑：联想10
目前共生产了1台
搬走了联想10
生产了一台电脑：神州11
目前共生产了1台
搬走了神州11
生产了一台电脑：联想12
目前共生产了1台
搬走了联想12
生产了一台电脑：神州13
目前共生产了1台
搬走了神州13
生产了一台电脑：联想14
目前共生产了1台
搬走了联想14
生产了一台电脑：神州15
目前共生产了1台
搬走了神州15
生产了一台电脑：联想16
目前共生产了1台
搬走了联想16
生产了一台电脑：神州17
目前共生产了1台
搬走了神州17
生产了一台电脑：联想18
目前共生产了1台
搬走了联想18
生产了一台电脑：神州19
目前共生产了1台
搬走了神州19