java线程通信

用输入和输出两个线程对同一对象进行操作

package javase;

class Resource{
    private String name;
    private String sex;
    private boolean flag = true;

    public synchronized void set(String name,String sex) {
        this.name = name;
        this.sex = sex;
    }
    
    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public synchronized void get() {
        System.out.println(name+"------"+sex);
    }
}

class Output implements Runnable{

    Resource r;
    public Output(Resource r) {
        super();
        this.r = r;
    }
    
    @Override
    public void run() {
        
        r.setFlag(true);
        while(true) {
            
            synchronized (r) {
                if(r.isFlag()) {
                    r.get();
                    r.setFlag(false);
                    r.notify();
                }
                try {
                    r.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
        }
        
    }
    
}

class Input implements Runnable{

    private int x=0;
    Resource r;
    public Input(Resource r) {
        super();
        this.r = r;
    }

    @Override
    public void run() {
        
        while(true) {
            synchronized (r) {
                
                if(r.isFlag()) 
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                if(x%2==0)
                    r.set("佩奇", "母猪");
                else
                    r.set("乔治", "公猪");
                x++;
                r.setFlag(true);
                r.notify();
            }
        }
        
    }
    
}

public class ResourceDemo {

    public static void main(String[] args) {
        
        Resource r = new Resource();
        Input in = new Input(r);
        Output out = new Output(r);
                
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        
        t1.start();
        t2.start();
        
    }

}

创建一个公用的对象给两个线程使用，一个为输入，一个为输出。当输入线程进入锁后会对对象元素进行赋值，唤醒锁对象线程池中的任意一个线程，然后使自己进入等待。此时输出线程拿到执行权，输出对象元素的值，再唤醒锁对象线程池中的任意一个线程，然后使自己进入等待。如此不断循环即可

多生产者多消费者案例

package javase;

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

class Resources{
    
    private String name;
    private int count = 1;
    private boolean flag = false;
    
    Lock lock = new ReentrantLock();
    
    Condition producer_con = lock.newCondition();
    Condition consumer_con = lock.newCondition();
    
    public void setName(String name) {
        
        lock.lock();
        try {
            while(flag)
                try {
                    producer_con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            
            this.name = name + count;
            System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
            count++;
            flag = true;
            consumer_con.signal();
        }
        finally {
            lock.unlock();
        }
        
        
    }
    
    public void get() {
        
        lock.lock();
        try {
            while(!flag)
                try {
                    consumer_con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        
            System.out.println(Thread.currentThread().getName()+"----消费者--"+this.name);
            flag = false;
            producer_con.signal();
        }
        finally {
            lock.unlock();
        }
        
            
        
    }
    
}

class Consumer implements Runnable{
    
    private Resources r;
    public Consumer(Resources r) {
        super();
        this.r = r;
    }

    @Override
    public void run() {
        while(true)
            r.get();
    }
    
}

class Producer implements Runnable{
    
    private Resources r;
    public Producer(Resources r) {
        super();
        this.r = r;
    }

    @Override
    public void run() {
        while(true)
            r.setName("烤鸭");
    }
    
}

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        
        Resources r = new Resources();
        
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        
        Thread t0 = new Thread(p);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(c);
        
        t0.start();
        t1.start();
        t2.start();
        t3.start();
        
    }

}

生产者每生产一个，消费者就消费一次。用Lock lock = new ReentrantLock();创建锁对象，用其中的方法创建两个监视器，用于分别监视消费者和生产者。开启线程后，生产者生产之前每次都会检查是否有物品，若有则进入等待，同时唤醒消费者线程。若没有则进行生产。消费者消费之前每次都会检查是否有物品。若有则消费。若没有则进入等待，同时唤醒生产者线程。