有关java多线程通讯的总结

   线程之间的通讯，常见的是生产者，消费者模型。

package com.cgroup.thread;

public class PC {

	public static void main(String[] args) {
		Q q = new Q();
		Consumer c = new Consumer(q);
		Producer p = new Producer(q);
	}

}

class Q {

	int n;
	boolean isValid;

	public synchronized int getN() {
		while (!isValid) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("get n:" + n);
		isValid = false;
		this.notify();
		return n;
	}

	public synchronized void setN(int n) {
		while (isValid) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		this.n = n;
		System.out.println("set n:" + n);
		isValid = true;
		this.notify();
	}

}

class Consumer extends Thread {
	Q q;

	public Consumer(Q q) {
		this.q = q;
		start();
	}

	public void run() {
		int i = 0;
		for (int j = 0; j < 10; j++) {
			q.setN(i++);
		}
	}
}

class Producer extends Thread {

	Q q;

	public Producer(Q q) {
		this.q = q;
		start();
	}

	public void run() {
		for (int i = 0; i < 10; i++) {
			q.getN();
		}
	}
}

还有一种是通过流，来实现线程之间的通讯。

 

package com.cgroup.thread;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Pipe {

	public static void main(String[] args) throws Exception {

		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream(in);
		Sender s = new Sender(out);
		Receiver r = new Receiver(in);
		Thread thread1 = new Thread(s);
		Thread thread2 = new Thread(r);
		thread1.start();
		thread2.start();
	}

}

class Sender implements Runnable {

	OutputStream out;

	public Sender(OutputStream out) {
		this.out = out;
	}

	public void run() {
		int value;

		try {
			for (int i = 0; i < 5; i++) {
				double tmp=Math.random() ;
				value = (int) (tmp*256);
				out.write(value);
				System.out.println("send:" + value);
				Thread.sleep((long) (Math.random() * 1000));
			}
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
}

class Receiver implements Runnable {

	InputStream in;

	public Receiver(InputStream in) {
		this.in = in;
	}

	public void run() {
		int value;

		try {
			while ((value = in.read()) != -1) {
				System.out.println("received:" + value);
			}
			System.out.println("pipe closed");
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

 

 

 

1.并不一定是，写数据需要保护，读数据就不需要保护。读，写，都需要保护

2.引发线程阻塞的原因有，调用了sleep方法，调用了wait方法，io操作，线程执行一个已经被锁住了的方法或者同步块。