java线程通信
用输入和输出两个线程对同一对象进行操作
1 package javase; 2 3 class Resource{ 4 private String name; 5 private String sex; 6 private boolean flag = true; 7 8 public synchronized void set(String name,String sex) { 9 this.name = name; 10 this.sex = sex; 11 } 12 13 public boolean isFlag() { 14 return flag; 15 } 16 17 public void setFlag(boolean flag) { 18 this.flag = flag; 19 } 20 21 public synchronized void get() { 22 System.out.println(name+"------"+sex); 23 } 24 } 25 26 class Output implements Runnable{ 27 28 Resource r; 29 public Output(Resource r) { 30 super(); 31 this.r = r; 32 } 33 34 @Override 35 public void run() { 36 37 r.setFlag(true); 38 while(true) { 39 40 synchronized (r) { 41 if(r.isFlag()) { 42 r.get(); 43 r.setFlag(false); 44 r.notify(); 45 } 46 try { 47 r.wait(); 48 } catch (InterruptedException e) { 49 e.printStackTrace(); 50 } 51 52 } 53 } 54 55 } 56 57 } 58 59 class Input implements Runnable{ 60 61 private int x=0; 62 Resource r; 63 public Input(Resource r) { 64 super(); 65 this.r = r; 66 } 67 68 @Override 69 public void run() { 70 71 while(true) { 72 synchronized (r) { 73 74 if(r.isFlag()) 75 try { 76 r.wait(); 77 } catch (InterruptedException e) { 78 e.printStackTrace(); 79 } 80 if(x%2==0) 81 r.set("佩奇", "母猪"); 82 else 83 r.set("乔治", "公猪"); 84 x++; 85 r.setFlag(true); 86 r.notify(); 87 } 88 } 89 90 } 91 92 } 93 94 public class ResourceDemo { 95 96 public static void main(String[] args) { 97 98 Resource r = new Resource(); 99 Input in = new Input(r); 100 Output out = new Output(r); 101 102 Thread t1 = new Thread(in); 103 Thread t2 = new Thread(out); 104 105 t1.start(); 106 t2.start(); 107 108 } 109 110 }
创建一个公用的对象给两个线程使用，一个为输入，一个为输出。当输入线程进入锁后会对对象元素进行赋值，唤醒锁对象线程池中的任意一个线程，然后使自己进入等待。此时输出线程拿到执行权，输出对象元素的值，再唤醒锁对象线程池中的任意一个线程，然后使自己进入等待。如此不断循环即可
多生产者多消费者案例
1 package javase; 2 3 import java.util.concurrent.locks.Condition; 4 import java.util.concurrent.locks.Lock; 5 import java.util.concurrent.locks.ReentrantLock; 6 7 class Resources{ 8 9 private String name; 10 private int count = 1; 11 private boolean flag = false; 12 13 Lock lock = new ReentrantLock(); 14 15 Condition producer_con = lock.newCondition(); 16 Condition consumer_con = lock.newCondition(); 17 18 public void setName(String name) { 19 20 lock.lock(); 21 try { 22 while(flag) 23 try { 24 producer_con.await(); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 29 this.name = name + count; 30 System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name); 31 count++; 32 flag = true; 33 consumer_con.signal(); 34 } 35 finally { 36 lock.unlock(); 37 } 38 39 40 } 41 42 public void get() { 43 44 lock.lock(); 45 try { 46 while(!flag) 47 try { 48 consumer_con.await(); 49 } catch (InterruptedException e) { 50 e.printStackTrace(); 51 } 52 53 System.out.println(Thread.currentThread().getName()+"----消费者--"+this.name); 54 flag = false; 55 producer_con.signal(); 56 } 57 finally { 58 lock.unlock(); 59 } 60 61 62 63 } 64 65 } 66 67 class Consumer implements Runnable{ 68 69 private Resources r; 70 public Consumer(Resources r) { 71 super(); 72 this.r = r; 73 } 74 75 @Override 76 public void run() { 77 while(true) 78 r.get(); 79 } 80 81 } 82 83 class Producer implements Runnable{ 84 85 private Resources r; 86 public Producer(Resources r) { 87 super(); 88 this.r = r; 89 } 90 91 @Override 92 public void run() { 93 while(true) 94 r.setName("烤鸭"); 95 } 96 97 } 98 99 public class ProducerConsumerDemo { 100 101 public static void main(String[] args) { 102 103 Resources r = new Resources(); 104 105 Producer p = new Producer(r); 106 Consumer c = new Consumer(r); 107 108 Thread t0 = new Thread(p); 109 Thread t1 = new Thread(p); 110 Thread t2 = new Thread(c); 111 Thread t3 = new Thread(c); 112 113 t0.start(); 114 t1.start(); 115 t2.start(); 116 t3.start(); 117 118 } 119 120 }
生产者每生产一个，消费者就消费一次。用Lock lock = new ReentrantLock();创建锁对象，用其中的方法创建两个监视器，用于分别监视消费者和生产者。开启线程后，生产者生产之前每次都会检查是否有物品，若有则进入等待，同时唤醒消费者线程。若没有则进行生产。消费者消费之前每次都会检查是否有物品。若有则消费。若没有则进入等待，同时唤醒生产者线程。
