java 多线程间通信（一）
synchronized同步
package com.test7;
public class Run {
public class MyObject {
private int a;
public MyObject(int a) {
this.a = a;
}
synchronized public void methodA() {
System.out.println("run methodA" + this.a);
this.a = 10;
}
}
public class ThreadA extends Thread {
private MyObject object;
public ThreadA(MyObject object) {
this.object = object;
}
@Override
public void run() {
object.methodA();
}
}
public class ThreadB extends Thread {
private MyObject object;
public ThreadB(MyObject object) {
this.object = object;
}
// 省略构造方法
@Override
public void run() {
object.methodA();
}
}
public static void main(String[] args) {
Run r = new Run();
MyObject object = r.new MyObject(5);
// 线程A与线程B 持有的是同一个对象:object
ThreadA a = r.new ThreadA(object);
ThreadB b = r.new ThreadB(object);
a.start();
b.start();
}
}
run methodA5
run methodA10
多个线程需要访问同一个共享变量、方法，谁拿到了锁（获得了访问权限），谁就可以执行。
wait/notify机制
package com.test7;
import java.util.ArrayList;
import java.util.List;
public class Test {
static public class MyList {
private static List<Integer> list = new ArrayList<Integer>();
public static void add(int i) {
list.add(i);
}
public static int size() {
return list.size();
}
}
public class ThreadA extends Thread {
private Object lock;
public ThreadA(Object lock) {
super();
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock) {
if (MyList.size() != 5) {
System.out.println("wait begin "
+ System.currentTimeMillis());
lock.wait();
System.out.println("Interruption!!!");
lock.notify();
lock.wait();
System.out.println("wait end "
+ System.currentTimeMillis());
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ThreadB extends Thread {
private Object lock;
public ThreadB(Object lock) {
super();
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock) {
for (int i = 0; i < 10; i++) {
MyList.add(i);
if (MyList.size() == 5) {
lock.notify();
System.out.println("已经发出了通知");
lock.wait();
}
System.out.println("添加了" + (i + 1) + "个元素!");
System.out.println(MyList.list.toString());
Thread.sleep(1000);
}
lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
try {
Test t = new Test();
Object lock = new Object();
ThreadA a = t.new ThreadA(lock);
a.start();
Thread.sleep(50);
ThreadB b = t.new ThreadB(lock);
b.start();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}wait begin 1535596248129
添加了1个元素!
[0]
添加了2个元素!
[0, 1]
添加了3个元素!
[0, 1, 2]
添加了4个元素!
[0, 1, 2, 3]
已经发出了通知
Interruption!!!
添加了5个元素!
[0, 1, 2, 3, 4]
添加了6个元素!
[0, 1, 2, 3, 4, 5]
添加了7个元素!
[0, 1, 2, 3, 4, 5, 6]
添加了8个元素!
[0, 1, 2, 3, 4, 5, 6, 7]
添加了9个元素!
[0, 1, 2, 3, 4, 5, 6, 7, 8]
添加了10个元素!
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
wait end 1535596258180
线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list 的size。
A,B之间如何通信的呢？也就是说，线程A如何知道 list.size() 已经为5了呢？
这里用到了Object类的 wait() 和 notify() 方法。
当条件未满足时(list.size() !=5)，线程A调用wait() 放弃CPU，并进入阻塞状态。不像while轮询那样占用CPU资源。
当条件满足时，线程B调用 notify()通知 线程A，所谓通知线程A，就是唤醒线程A，并让它进入可运行状态。
这种方式的一个好处就是CPU的利用率提高了。
管道通信
管道流主要用来实现两个线程之间的二进制数据的传播，下面以PipedInputStream类和PipedOutputStream类为例，实现生产者-消费者：
package com.test7;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class PipeTest {
/**
* 我们以数字替代产品 生产者每5秒提供5个产品，放入管道
*/
class MyProducer extends Thread {
private PipedOutputStream outputStream;
private int index = 0;
public MyProducer(PipedOutputStream outputStream) {
this.outputStream = outputStream;
}
@Override
public void run() {
while (true) {
try {
for (int i = 0; i < 5; i++) {
index++;
System.out.println("放入产品：" + index);
outputStream.write(index);
}
} catch (IOException e) {
e.printStackTrace();
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 消费者每0.5秒从管道中取1件产品，并打印剩余产品数量，并打印产品信息（以数字替代）
*/
class MyConsumer extends Thread {
private PipedInputStream inputStream;
public MyConsumer(PipedInputStream inputStream) {
this.inputStream = inputStream;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
int count = inputStream.available();
if (count > 0) {
System.out.println("剩余产品数量: " + count);
System.out.println("得到产品: " + inputStream.read());
} else {
System.out.println("未取到产品");
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
public static void main(String[] args) {
PipeTest t = new PipeTest();
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream();
try {
pis.connect(pos);
} catch (IOException e) {
e.printStackTrace();
}
t.new MyProducer(pos).start();
t.new MyConsumer(pis).start();
}
}
放入产品：1
放入产品：2
放入产品：3
放入产品：4
放入产品：5
剩余产品数量: 5
得到产品: 1
剩余产品数量: 4
得到产品: 2
剩余产品数量: 3
得到产品: 3
剩余产品数量: 2
得到产品: 4
剩余产品数量: 1
得到产品: 5
未取到产品
未取到产品
未取到产品
未取到产品
未取到产品
放入产品：6
放入产品：7
放入产品：8
放入产品：9
放入产品：10
剩余产品数量: 5
得到产品: 6
剩余产品数量: 4
得到产品: 7
剩余产品数量: 3
得到产品: 8
剩余产品数量: 2
得到产品: 9
剩余产品数量: 1
得到产品: 10
...
