黑马程序员_Java基础：实现多线程对共有数据的同步操作

      实现多线程对共有数据的同步操作，主要涉及到多线程和同步。

      虽然都是基础，但是这把刀还是要用熟练，等到使用的时候才能得心应手。

 

以下是示例：

/*
 * 需求：有生产者和消费者，生产者生产一个，消费者才能消费一个，但如果消费者不消费，也不能生产。
 * 知识点：同步，多线程,等待唤醒机制，单例设计模式。*/
package com.gzjzone.jul242015;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ProducerConsumerTest {
    public static void main(String[] args) {
        new Thread(new Producer()).start();
        new Thread(new Consumer()).start();
        new Thread(new Producer()).start();    //多生产者。
        new Thread(new Consumer()).start();    //多消费者。
    }

}

class Product{
//    单例设计模式：饿汉式。
    private Product(){};
    private static Product product = new Product();
    public static Product getProduct(){
        return product;
    }
    private int pro = 0;
    private boolean flag = false;
    
//    同步设置
    private Lock lock = new ReentrantLock();
    private Condition con_pro = lock.newCondition();
    private Condition con_con = lock.newCondition();
    
    public void setPro(int pro){
        this.pro = pro;
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    public int getPro(){
        return pro;
    }
    public boolean getFlag(){
        return flag;
    }
    public Lock getLock(){
        return lock;
    }
    public Condition getCon_pro(){
        return con_pro;
    }
    public Condition getCon_con(){
        return con_con;
    }
}

class Producer implements Runnable {
    Product product = Product.getProduct();
    Lock lock = product.getLock();
    Condition con_pro = product.getCon_pro();
    Condition con_con = product.getCon_con();
    public void run() {
        while (true) {
            lock.lock();
            try {
//                使用while循环判断标记，可以让线程被唤醒后再次判断while的条件标记。
                while (product.getFlag()) 
                    con_pro.wait();    
                int pro = product.getPro();
                System.out.println(Thread.currentThread().getName()+"生产..."+(++pro));
                product.setPro(pro);
                product.setFlag(true);
            } catch (InterruptedException e) {
                System.out.println("中断异常");
            } finally{
                con_con.signal();;
                lock.unlock();
            }            
        }
        
    }
}

class Consumer implements Runnable {
    Product product = Product.getProduct();
    Lock lock = product.getLock();
    Condition con_pro = product.getCon_pro();
    Condition con_con = product.getCon_con();
    public void run() {
        while (true) {
            lock.lock();
            try {
                while (!(product.getFlag()))
                    con_con.wait();
                int pro = product.getPro();
                System.out.println(Thread.currentThread().getName()+"消费..........."+pro--);
                product.setPro(pro);
                product.setFlag(false);
            } catch (InterruptedException e) {
                System.out.println("中断异常");
            } finally{
                con_pro.signal();
                lock.unlock();
            }
        }            
    }        
}

 

      运行结果为多个线程不断循环生产1个，消费1个，可以看出生产行为和消费行为达到多线程同步，满足需求。

      其中关键点：

      1.产品是生产者和消费者的共用数据，利用单例设计模式创建产品对象，确认唯一性。
　　2.设置标记，通过标记来控制生产消费的次序。