1、等待/通知机制
线程间通讯可以采用while语句轮询检测某一条件，缺点是线程主动操作、读取、判断同一个变量，此方法浪费CPU资源。
1.1 等待/通知机制的实现
- wait()方法和notify()方法
1、要在同步方法或同步代码块中调用，即必须在调用前先获取该对象锁，若没有会抛出IllegalMonitorStateException。
2、执行wait()方法后，线程停止运行并释放锁，后续代码不执行；
3、notify()方法用来通知呈wait状态的线程，随机挑选一个对其发送通知并使其转为就绪状态，获取对象锁并执行后续代码。执行notify()方法不会立即释放锁，需要等待线程将程序执行完成。
4、notifyAll()方法可以通知所有在等待同一资源的线程全部进入就绪状态。
public class MyList
{
//此处必须将变量定义为static，方法定义为public方便访问
private static List list = new ArrayList();
public static void add()
{
list.add("myString");
}
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");
lock.wait();
System.out.println("wait end");
}
}
}
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();
if(MyList.size() == 5)
{
System.out.println("notify begin");
lock.notify();
System.out.println("notify end");
}
System.out.println("add 第" + (i+1) + "个元素");
}
}
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
public class Run
{
public static void main(String[] args)
{
try
{
Object lock = new Object();
ThreadA a = new ThreadA(lock);
a.start();
Thread.sleep(50);
ThreadB b = new ThreadB(lock);
b.start();
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
- 每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储将要获取锁的线程，阻塞队列存储被阻塞的线程。
- wait()方法被执行后，锁被自动释放，执行完notify()方法锁不会立即释放，等待notify()方法所在的代码块代码全部执行完成。
- wait(long)方法：等待某一段时间内是否有线程对锁进行唤醒，超过这个时间线程会自动唤醒。
1.2 生产者/消费者模式的实现
- 一生产者赋值，一消费者读取
public class Consumer
{
private Object lock;
public Consumer(Object lock)
{
this.lock = lock;
}
public void getValue()
{
try
{
synchronized (lock)
{
if(Value.getValue().equals(""))
{
lock.wait();
}
System.out.println("Consumer get " + Value.getValue());
Value.setValue("");
lock.notify();
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public class Produce
{
private Object lock;
public Produce(Object lock)
{
this.lock = lock;
}
public void setValue()
{
try
{
synchronized (lock)
{
if(!Value.getValue().equals(""))
{
lock.wait();
}
String value = System.currentTimeMillis()+"";
System.out.println("Produce set " + value);
Value.setValue(value);
lock.notify();
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public class ConsumerThread extends Thread
{
private Consumer consumer;
public ConsumerThread(Consumer consumer)
{
super();
this.consumer = consumer;
}
@Override
public void run()
{
while(true)
{
consumer.getValue();
}
}
}
public class ProduceThread extends Thread
{
private Produce produce;
public ProduceThread(Produce produce)
{
super();
this.produce = produce;
}
@Override
public void run()
{
while(true)
{
produce.setValue();
}
}
}
public class Value
{
//设置初值
private static String value = "";
public static void setValue(String valueSet)
{
value = valueSet;
}
public static String getValue()
{
return value;
}
}
public class Main
{
public static void main(String[] args)
{
Object lock = new Object();
Produce produce = new Produce(lock);
ProduceThread produceThread = new ProduceThread(produce);
Consumer consumer = new Consumer(lock);
ConsumerThread consumerThread = new ConsumerThread(consumer);
produceThread.start();
consumerThread.start();
}
}
运作机制：
以value值作为切入点，当value值为""时，消费者线程为wait状态，生产者获取锁对value赋值，完成赋值后notify并释放锁，消费者被唤醒，获取生产者给value赋的值，并将value值设置回""，notify并释放锁。
- 多生产者/多消费者实现
假死：因为线程notify的对象有可能是异类，也有可能是同类，连续多次唤醒同类，这就有可能导致所有的线程都进入waiting状态，从而任务无法正常执行即假死。
解决方法：使用notifyAll()方法
public class Stack
{
private List list = new ArrayList();
synchronized public void push()
{
try
{
//此处由if改为while，条件改变时无法得到及时响应
//唤醒多个wait状态的线程，pop中的remove出错。
while(list.size() == 1)
{
this.wait();
}
list.add("anyString"));
this.notify();
System.out.println("push " + list.size());
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
synchronized public void pop()
{
try
{
while(list.size() != 1)
{
this.wait();
}
list.remove(0);
//通知同类和异类
this.notifyAll();
System.out.println("pop" + list.size());
}
}
}
*交叉备份实现
public class BackUpTool
{
private boolean backToA = false;
synchronized public void backUpA()
{
try
{
while (backToA == false)
{
wait();
}
System.out.println("Backup to A");
backToA = false;
notifyAll();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
synchronized public void backUpB()
{
try
{
while (backToA == true)
{
wait();
}
System.out.println("Backup to B");
backToA = true;
notifyAll();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public class ThreadA extends Thread
{
private BackUpTool backUpTool;
public ThreadA(BackUpTool tool)
{
super();
this.backUpTool = tool;
}
@Override
public void run()
{
backUpTool.backUpA();
}
}
public class ThreadB extends Thread
{
private BackUpTool backUpTool;
public ThreadB(BackUpTool tool)
{
super();
this.backUpTool = tool;
}
@Override
public void run()
{
backUpTool.backUpB();
}
}
public class Run
{
public static void main(String[] args)
{
BackUpTool backUpTool = new BackUpTool();
for(int i = 0; i < 20; i++)
{
ThreadA threadA = new ThreadA(backUpTool);
ThreadB threadB = new ThreadB(backUpTool);
threadA.start();
threadB.start();
}
}
}
2、通过管道进行线程间通信
管道流(pipeStream)是一种特殊的流，用于不同线程间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道读取数据。
字节流 PipedInputStream、PipedOutputStream
字符流 PipedReader、PipedWriter
import java.io.IOException;
import java.io.PipedOutputStream;
public class WriteData
{
public void wirteMethod(PipedOutputStream out)
{
try
{
System.out.println("Write:");
for(int i=0; i<300;i++)
{
String outData = "" + (i+1);
//0到299写入到输出管道
out.write(outData.getBytes());
System.out.print(outData);
}
System.out.println();
out.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
import java.io.PipedOutputStream;
public class ThreadWrite extends Thread
{
private WriteData writeData;
private PipedOutputStream out;
public ThreadWrite(WriteData writeData, PipedOutputStream out)
{
super();
this.writeData = writeData;
this.out = out;
}
@Override
public void run()
{
writeData.wirteMethod(out);
}
}
import java.io.IOException;
import java.io.PipedInputStream;
public class ReadData
{
public void readMethod(PipedInputStream input)
{
try
{
System.out.println("Read:");
byte[] byteArray = new byte[20];
//到输入管道里读取数据到byteArray数组中
//返回数组大小
int readLength = input.read(byteArray);
while(readLength != -1)
{
String newData = new String(byteArray,0,readLength);
System.out.println(newData);
readLength = input.read(byteArray);
}
System.out.println();
input.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
import java.io.PipedInputStream;
public class ThreadReader extends Thread
{
private ReadData readData;
private PipedInputStream input;
public ThreadReader(ReadData readData, PipedInputStream input)
{
super();
this.readData = readData;
this.input = input;
}
@Override
public void run()
{
readData.readMethod(input);
}
}
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class Run
{
public static void main(String[] args)
{
try
{
WriteData writeData = new WriteData();
ReadData readData = new ReadData();
PipedInputStream inputStream = new PipedInputStream();
PipedOutputStream outputStream = new PipedOutputStream();
inputStream.connect(outputStream);
ThreadReader threadReader = new ThreadReader(readData, inputStream);
ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
threadWrite.start();
Thread.sleep(2000);
threadReader.start();
}
catch (IOException e)
{
e.printStackTrace();
}
catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
3、join()方法
3.1 join()方法使用方式
class Run
{
public static void main(String[] args)
{
Thread thread = new Thread();
thread.start();
//加上join语句可以保证在thread线程结束后再执行打印end操作
thread.join();
System.out.println("end");
}
}
方法join()的作用是使所属的线程对象thread正常执行完run()方法中的任务，而使当前的线程main进行无限期的阻塞，等待线程thread销毁后再继续执行线程main后面的代码。
3.2 join(long)与sleep(long)的区别
方法join(long)的功能在内部使用wait(long)来实现的，因此具有释放锁的特点；而sleep(long)方法不是释放锁。
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
4、类ThreadLocal作用
每个线程绑定自己的值，ThreadLocal类可以存储每个线程的私有数据。每个线程可以获取到各自设置的值，互不影响，隔离性。
public class Tools
{
public static ThreadLocal t1 = new ThreadLocal();
}
public class ThreadA extends Thread
{
@Override
public void run()
{
try
{
for(int i = 0; i < 100; i++)
{
Tools.t1.set("ThreadA" + (i+1));
System.out.println("ThreadA get " + Tools.t1.get());
Thread.sleep(1000);
}
}
catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
public class ThreadB extends Thread
{
@Override
public void run()
{
try
{
for(int i = 0; i < 100; i++)
{
Tools.t1.set("ThreadB" + (i+1));
System.out.println("ThreadB get " + Tools.t1.get());
Thread.sleep(1000);
}
}
catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
public class Run
{
public static void main(String[] args)
{
try
{
ThreadA threadA = new Thread();
ThreadB threadB = new Thread();
threadA.start();
threadB.start();
for(int i = 0; i < 100; i++)
{
Tools.t1.set("Main" + (i+1));
System.out.println("Main get " + Tools.t1.get());
Thread.sleep(1000);
}
}
catch (InterruptedException ex)
{
ex.printStackTrace();
}
}
}
InteritableThreadLocal类可以让子线程从父类线程中取得值。
