线程间通讯

线程间通讯

多个线程在处理同一个资源，但是任务却不同时，需要使用线程间通讯。

为了实现线程间通信，需要借助Object类提供的wait()、notify()、notifyAll()三个方法。这三个方法不属于Thread，而是Object。这三个方法必须有同步监视器对象调用。

因为监视器对象可以是任意的object对象，任意的对象都能够调用的方法可定得写在object中。

对于synchronized修饰的方法，因为同步监视器默认就是this，所以可以在同步方法中直接调用这三个方法。

对于synchronized修饰的同步代码块。同步器是synchronized后面括号里的对象，所以必须使用括号里的对象调用这三个方法。

这三个方法的作用：

wait()：是当前的进程等待，直到其他线程调用该同步器的notify()方法或notifyAll()来唤醒线程。调用wait()方法的线程会释放对该同步器的锁定。

notify(): 唤醒在此同步器上的等待的单个线程。如果多个线程在同步器上等待，则会随机的唤醒一个。只有当前线程放弃了对同步器的锁定后，才可以执行被唤醒的线程。

notifyAll()：唤醒在此同步器上的所有线程。只有当前线程放弃了对同步器的锁定后，才可以执行被唤醒的线程。

下面实现了一个生产消费的流程，当生产者生产完成后通知消费者消费，当消费了之后通知生产者接着生产。生产和消费交替进行。

public class ProducerConsumer {

public static void main(String[] args) {
Resouse account = new Resouse() ;
Producer producer = new Producer(account) ;
Consumer consumer = new Consumer(account);
//生产线程
Thread t1 = new Thread(producer);
//消费线程
Thread t3 = new Thread(consumer);
t1.start();
t3.start();

}
}

class Resouse {
//生产的资源，每次生产就加1，消费就输出数值。
int sum = 0 ;
//记录生产消费的状态
Boolean flag = false;
//生产方法，由于save()和out()方法同时都会操作资源所以加锁
//根据flag判断状态，如果完成了生产，线程阻塞（通过wait 使线程等待，并释放锁）。当out方法唤醒线程继续向下执行。
//如果没有完成生产，直接生产，并将状态改为完成生产，唤醒消费线程。
synchronized void save(){
if(flag){
try {
//线程阻塞
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//唤醒在this上等待的方法
notifyAll();
flag = true ;
sum++ ;
System.out.println("producer"+sum);

}
//消费方法：当生产完成后，生产线程会通知消费线程。消费线程获得锁后，进行消费
//消费完成后给该状态，通知生产进程进行生产。
synchronized void out(){
if(!flag){
try {
//线程阻塞
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else
//唤醒在this上等待的方法
notifyAll();
flag = false ;
System.out.println("consumer<<<"+sum);
}
}

//生产线程的Target，调用一百次生产方法
class Producer implements Runnable{
Resouse account ;
public Producer(Resouse account ){
this.account = account ;
}
public void run(){
for(int i=0;i<100;i++){
account.save();
}
}
}

//消费线程的Target，调用一百次消费方法。
class Consumer implements Runnable{
Resouse account ;
public Consumer(Resouse account ){
this.account = account ;
}
public void run(){
for(int i=0;i<100;i++){
account.out();
}
}
}

上面的程序使用wait()和notify()进行控制。对于生产线程而言，当程序进入save()方法后，如果flag是true，则表明已经生产了，程序调用wait()方法阻塞线程；否则程序向下执行生产操作，当生产完成了将flag设置成true，再盗用notifyAll（）唤醒其他被阻塞的线程。消费线程就开始执行。

使用Conditon控制线程通讯

当程序不实用synchronized关键子来保证同步，而直接使用Lock对像来控制同步。系统中不存在隐式的同步监视器，不能使用wait() 、notify()、notifyAll()方法进行线程通讯。

当使用Lock对象保证线程同步时，可以使用Condition类来进行线程通讯。

Conditon提供可跟上面功能相近的方法

await():类是于隐式同步器上的wait()方法，导致当前线程等待，知道其他线程调用该Conditon的signal()方法或是signalAll()方法来唤醒该线程。

signal()：唤醒在当前Lock上等待的单个线程，如果在Lock对象上有多个线程等待，则会随机的唤醒一个。只有当前线程放弃了对Lock对象的锁定后，才能执行被唤醒的方法。

signalAll()：唤醒在当前Lock上等待的所有线程。只有当前线程放弃了对Lock对象的锁定后，才能执行被唤醒的方法。

public class ProducerConsumer {

public static void main(String[] args) {
Resouse account = new Resouse() ;
Producer producer = new Producer(account) ;
Consumer consumer = new Consumer(account);
//生产线程
Thread t1 = new Thread(producer);
Thread t2 = new Thread(producer);
Thread t3 = new Thread(producer);
//消费线程
Thread t4 = new Thread(consumer);
t1.start();
t3.start();
t2.start();
t4.start();

}
}

class Resouse {
//new 一个Lock的实例
Lock lock = new ReentrantLock();
//同过lock获得Conditon
Condition conditon = lock.newCondition();

Condition con_producer = lock.newCondition();
Condition con_consuner = lock.newCondition();

int sum = 0 ;

Boolean flag = false;

public void save(){
lock.lock();
try{
while(flag){
try {
con_producer.await();
} catch (InterruptedException e) {

e.printStackTrace();
}
}
con_consuner.signal();
flag = true ;
sum++ ;
System.out.println("producer"+sum);
}finally{
lock.unlock();
}

}

public void out(){
lock.lock();
try{
while(!flag){
try {
con_consuner.await();
} catch (InterruptedException e) {

e.printStackTrace();
}
}
con_producer.signal();
flag = false ;
System.out.println("consumer<<<"+sum);
}finally{
lock.unlock();
}
}
}

class Producer implements Runnable{
Resouse account ;
public Producer(Resouse account ){
this.account = account ;
}
public void run(){
for(int i=0;i<100;i++){
account.save();
}
}
}

class Consumer implements Runnable{
Resouse account ;
public Consumer(Resouse account ){
this.account = account ;
}
public void run(){
for(int i=0;i<100;i++){
account.out();
}
}
}

停止线程

当线程任务中的循环结束的时候，线程就停止了。只要控制循环就可以结束线程。

控制循环通常用定义标记来完成。

public class StopThread implements Runnable{
Boolean flag = true ;
public static void main(String args []){
StopThread s = new StopThread();
Thread t = new Thread(s) ;
Thread t2 = new Thread(s) ;
t.start();
t2.start();

//主线程sleep 1秒后 设置 flag为false。子线程停止
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
s.setFlag();

}

public void run(){
while(flag){
System.out.println(Thread.currentThread().getName());
}
}

void setFlag(){
flag = false ;
}

}

如果线程处于冻结状态，无法读取标记如何结束

可使用interrupt()方法将处于冻结状态的线程强行恢复过来。强行打断会发生InterruptedException，处理Excepiton是将flag设置为false。

public class StopThread implements Runnable{
Boolean flag = true ;
public static void main(String args []){
StopThread s = new StopThread();
Thread t = new Thread(s) ;
t.start();

//主线程sleep 1秒后 打断线程t。子线程停止
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t.interrupt();
}

public synchronized void run(){
while(flag){
try {
wait();
} catch (InterruptedException e) {
//处理异常，将flag设置成false
flag = false ;
e.printStackTrace();
}

}
System.out.println(Thread.currentThread().getName()+"over");
}
}