多线程通信

一个类对象作为另一个类的属性，你可以通过构造函数的形式传递进来。就是说当你想在一个类A中使用另一个类B的数据时，可以在该类A中定义B的对象b作为A的属性，再把b作为一个参数构造一个构造函数，这样就可以实现参数的传递，可以在类A中使用B的数据了（如果没有理解错应该是这样子的意思）。

void wait()	使当前线程放弃同步锁并进入等待状态，直到其他线程进入此同步锁，并调用notify（）方法，或notifyAll()方法唤醒该线程为止
void notify()	唤醒此同步锁上等待的第一个调用wait()方法的线程
viod notifyAll()	唤醒此同步锁上调用wait()方法的所有线程

多线程通信利用wait()、notify()、notifyAll()使得线程使多个线程按照一定的顺序轮流执行。

注意：这三个方法的调用者都应该是同步锁对象。

package study;
class Storage{
private int[] cells=new int[10];
private int inPos,outPos;
private int count;
public synchronized void put(int num) {

try {
while(count==cells.length){
this.wait();
}
cells[inPos]=num;
System.out.println("在cells["+inPos+"]中放入数据---"+cells[inPos]);
inPos++;
if(inPos==cells.length)
inPos=0;
count++;
this.notify();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}


}
public synchronized void get(){
try {
while(count==0){
this.wait();
}
int data=cells[outPos];
System.out.println("从cells["+outPos+"]中取出数据"+data);
cells[outPos]=0;
outPos++;
if(outPos==cells.length)
outPos=0;
count--;
this.notify();

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
class Input implements Runnable{
private Storage st;
private int num;
public Input(Storage st){
this.st=st;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
st.put(num++);
}
}
}


class Output implements Runnable{
private Storage st;
public Output(Storage st) {
// TODO Auto-generated constructor stub
this.st=st;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
st.get();
}
}
}
public class Example17 {
public static void main(String[] args) {
Storage st=new Storage();
Input  input=new Input(st);
Output output=new Output(st);
new Thread(input).start();
new Thread(output).start();
}
}

结果：

出现问题：

传入put()的参数num初始值应该是0，不知道为什么不能从0开始，即使是在定义属性值num时赋值num=0也同样不可以，找不出问题所在。

还有一个问题是，wait()和notify()的定义中说”其他线程进入此同步锁“，对于这点，目前的理解是这样子的，不知道有没有理解错：

对象锁是基于调用被synchronized修饰的方法所在的对象层次来讲的，并不是之前理解的那样是基于被synchronized修饰的方法的，同一个类中会有两个或者多个被synchronized修饰的方法，是为了使这两个方法同步，所谓同步就是某个资源在同一时间内只能被一个线程访问。这里的资源应该就是一个对象锁（应该可以这么理解吧），被synchronized修饰的两个或者多个方法是对象锁内的同步的方法，不管多个线程利用同步方法中的哪个方法，只能有一个线程占用该对象所。