java基础（十一）：多线程

//产品类
public class Product {
    private String name;//馒头 玉米饼
    private String color;//白色 黄色
    private boolean isProduce = false;//是否生产产品
    public synchronized void get(){
        //如果没有生产，等待
        if(isProduce == false)
        {
            wait();
        }
    
        System.out.println(“消费者消费:”+name+“ ”+color); //消费产品
        isProduce = false; //修改状态：没有生产
        notify();//通知生产者生产
    }
    public synchronized void put(String name,String color){
        //如果已经生产，等待
        if(isProduce == true){    
            wait();//生产产品
        }
        this.name = name;
        this.color = color;
        System.out.println("生产者生产："+this.name+" "+this.color);
        isProduce = true; //修改状态：已经生产
        notify(); //通知消费者消费
    }
}

//消费者线程
public class Consumer implements Runnable{
    private Product product;
    public Consumer() {
        super();
    }
    public Consumer(Product product) {
        super();
        this.product = product;
    }
    public void run() {
        while(true){
            product.get();
        }
    }
}

//生产者线程
public class Producer implements Runnable {
    private Product product;
    public Producer() {  }
    public Producer(Product product) {
        this.product = product;
    }
    public void run() {
        int i = 0;
        while (true) {
            if (i % 2 == 0) {
                product.put("馒头", "白色");
            } else {
                product.put("玉米饼", "黄色");
            }
            i++;
        }
    }
}

//测试类
public class TestCommunication {
    public static void main(String[] args) {
        //创建产品类（生产者和消费者操作的是同一个产品）
        Product product = new Product();
        //创建两个线程
        Consumer c = new Consumer(product);
        Thread t1 = new Thread(c);
        Producer p = new Producer(product);
        Thread t2 = new Thread(p);
        //启动两个线程
        t1.start();
        t2.start();
    }
}

/**
 * 测试两种实现线程方式的区别
 *         区别
 * 
 * @author Terry
 *
 */
public class ThreadDemo3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        //new了两个线程对象——s1和s2
        //其中两个对象各对应一个内存区域。线程运行过程中运行都是自己内存块中的数据        
        Shop1 s1 = new Shop1("小武");
        s1.start();
        
        Shop1 s2 = new Shop1("小潘");
        s2.start();
        
        /*
        //实例化了两个线程对象，所以分配了两块内存空间
        //执行过程中操作的是自己的内存空间
        Shop2 s3 = new Shop2("小武");
        s3.run();    
        
        Shop2 s4 = new Shop2("小潘");
        s4.run();
        
        
        //实际实例化了两个线程对象
        //所以同样分配两个内存空间
        Thread t1 = new Thread(new Shop2("小武"));
        t1.start();
        
        Thread t2 = new Thread(new Shop2("小潘"));
        t2.start();
        
        
        //创建了两个线程对象，但是使用的是同一个对象——s5        
        Shop2 s5 = new Shop2("w");
        Thread t3 = new Thread(s5);
        t3.start();
        
        Thread t4 =new Thread(s5);
        t4.start();
        */
        
    
        

        
    }
}

/**
 * 因为业务的拓展，现在可以实现多窗口的出售
 *         要求：每天只卖10个
 * @author Terry
 *
 */
class Shop1 extends Thread{
    //private int count = 10;
    //使用静态变量可以有效的实现资源共享（因为在内存中只有一份count）
    private static int count = 10;
    public Shop1(String name) {
        super(name);
    }
    public void run(){
        //判断是否已经卖完
        while(count>0){
            count--;
            System.out.println(this.getName() +"卖出了一个烧饼" + ",现在剩余" + count);
        }
    }
}

/**
 * 使用接口实现上面的代码
 * @author Terry
 *
 */
class Shop2 implements Runnable{
    //私有变量，存储剩余烧饼的个数
    private int count = 10;
    //存储当前人的姓名
    private String name="";
    
    public Shop2(String name) {
        this.name  = name;
    }
    
    /**
     * 实现销售的方法
     */
    public void run(){
        //判断是否已经卖完
        while(count>0){
            count--;
            System.out.println(Thread.currentThread().getId() + "、" + this.name +"卖出了一个烧饼" + ",现在剩余" + count);
        }
    }
}