线程间的通讯和生产者和消费者之间的问题

/*
线程间通信
多个线程在处理同一资源，但是任务却不同。

* */
//资源
class Resource{
String name;
String sex;

}

//输入
class Input implements Runnable{
Resource r;
Input(Resource r){
this.r=r;
}
public void run(){
int x=0;
while(true){
synchronized (r) {

if(x==0){
r.name="mike";
r.sex="nan";
}else{
r.name="丽丽";
r.sex="女女女女女女女";
}
x=(x+1)%2;
}
}
}
}

//输出
class Output implements Runnable{

Resource r;
Output(Resource r){
this.r=r;
}
public void run() {

while(true){
synchronized(r){
System.out.println(r.name+"....."+r.sex);
}}

}

}
public class Thread23_1 {
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();
}
}

多线程(线程间通信-等待唤醒机制)

等待/唤醒机制。

涉及的方法:

1.wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。

2.notify():唤醒线程池中一个线程（任意）

3.notifyAll():唤醒线程池中的所有线程

这些方法都必须定义在同步中。

因为这些方法是用于操作线程状态的方法。

必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了

Object类中的?

因为这些方法是监视器的方法，监视器其实就是锁。

锁可以是任意的对象，任意的对象调用的方式一定定义在Object中。

//资源
class Resource{
String name;
String sex;

boolean flag=false;
}

//输入
class Input implements Runnable{
Resource r;
Input(Resource r){
this.r=r;
}
public void run(){
int x=0;
while(true){
synchronized (r) {

if(r.flag){//真，进入等待
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(x==0){
r.name="mike";
r.sex="nan";
}else{
r.name="丽丽";
r.sex="女女女女女女女";
}
r.flag=true;
r.notify();
}
x=(x+1)%2;
}
}
}

//输出
class Output implements Runnable{

Resource r;
Output(Resource r){
this.r=r;
}
public void run() {

while(true){
synchronized(r){
if(!r.flag){
try {
r.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(r.name+"....."+r.sex);
r.flag=false;
r.notify();
}}

}

}
public class Thread24_1 {
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();
}
}

生产者和消费者

/*
生产者，消费者。

多生产者，多消费者的问题。

if判断标记，只有一次，会导致不该运行的线程运行了，出现了数据错误的情况。

while判断标记,解决了线程获取执行权后，是否要运行。

notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。
notifyAll解决了本方线程一定会唤醒对方线程的问题。
* */
class Resource{
private String name;
private int count=1;
private boolean flag=false;
public synchronized void set(String name){
while(flag){
try {
this.wait();//唤醒的线程在这里开始运行
//0
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name=name+count;
count++;
System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
flag=true;//0  烤鸭1
//notifyAll();
notify();
}
public synchronized void out(){

while(!flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"..消费者......."+this.name);
flag=false;
//notifyAll();
notify();
}
}

class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r=r;
}

public void run() {
while(true){
r.set("烤鸭");
}

}

}

class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r=r;
}

public void run() {
while(true){
r.out();
}

}
}
public class Thread26_1 {
public static void main(String[] args) {
Resource r=new Resource();
Producer pro=new Producer(r);
Consumer con=new Consumer(r);

Thread t0=new Thread(pro);
Thread t1=new Thread(pro);
Thread t2=new Thread(con);
Thread t3=new Thread(con);
t0.start();
t1.start();
t2.start();
t3.start();

}
}