JAVA线程---线程之间的协作

java线程第三章，主要介绍线程之间的协作，我们进行多线程，肯定需要线程之间的协作，什么时候挂起，什么时候等待，如何进行上面的操作，以及操作的时机控制，首先先简单介绍一些基本的，后期通过项目中的实际操作，继续更新。

协作解决的具体问题：

当多线程(任务)进行协作时，关键是任务之间的通信，如何握手。这里仍然可以使用基础特性：互斥。互斥可以确保只有一个任务可以响应某种信号，这样就解决了资源冲突的问题，此外我们还需要为任务提供一种等待机制，可以在某个时候将自身挂起，等到外界的条件到了可以执行的时候，再让这个任务继续开动。比如盖房子的打地基，铺水泥和上钢筋，我们可以先同时进行打地基和铺水泥中的生成水泥任务，当生成水泥的任务完成时，由于地基没有完成，此时可以将铺水泥任务挂起，知道收到地基完成的信号，此时再继续进行铺水泥任务。

Java提供的方法：1）object 的 wait 和 notify

2）并发库的await和signal的Condition对象

1，wait和notify

Wait：等待某个条件发生变化，通常该条件的变化有其他任务执行使其发生变化。

1）调用wait方法时，与sleep和yield不同，已将所释放。直到某个条件发生变化，调用notify或notifyall去唤醒该任务，它才会去尝试取得锁，执行任务。并不会立刻执行

2）调用wait方法的线程，要不传入等待时间，否者只能通过notify或notifyall去唤醒

3）实现时，必须放在同步块里和同步方法中，否则在运行中或报错。

wait和notify都是object的方法

4）通常的实现方式，一般放在while里面。

具体实例:

资源的封装类：

package thridOperate.operate;

import Util.PrintUtil;

import java.util.concurrent.TimeUnit;

/**一个汽车封装类，模拟汽车的某个操作，前后具有依赖关系
* Created by acer on 2016/2/29.
*/
public class Car {

private boolean chckeon = false;

/**
* 冲水操作
*
* @author sn
* @date 2016/2/29  11:15
*/
public synchronized void wateron() {
chckeon = true; //wait for dry
//PrintUtil.printb("Car is watering");
notifyAll();
}

/**
* 擦水操作
* @author sn
* @date 2016/2/29  11:17
*/
public synchronized void drycar() {
if (chckeon) {
try {
TimeUnit.MILLISECONDS.sleep(5);  //模拟具体的过程
//PrintUtil.printb("Car is drying");
} catch (InterruptedException e) {
e.printStackTrace();
}
chckeon = false;
notifyAll();
}
}

/**
* 等待冲水
*
* @author sn
* @date 2016/2/29  11:17
*/
public synchronized void waitforWater() {
while (!chckeon) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//PrintUtil.printb("wari for watering the car");
}

/**
* 等待擦水
*
* @author sn
* @date 2016/2/29  11:17
*/
public synchronized void watiforDry() {
while (chckeon) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//PrintUtil.printb("the car is wait for drying");
}

}

不同任务的Runnable实现类：

package thridOperate.operate;

import Util.PrintUtil;
import thridOperate.operate.Car;

import java.util.concurrent.TimeUnit;

/**对汽车进行干燥操作
* Created by acer on 2016/2/29.
*/
public class DryCar  implements Runnable {

private Car car;

public DryCar(Car car) {
this.car = car;
}

@Override
public void run() {
while (!Thread.interrupted()) {

try {
car.drycar();
car.waitforWater();
TimeUnit.MILLISECONDS.sleep(100);
PrintUtil.priintall("dry is finish \n");
} catch (InterruptedException e) {
PrintUtil.priintall("Exit via interrupt \n");
return;
}
}
PrintUtil.priintall("Task of end");

}
}

package thridOperate.operate;

import Util.PrintUtil;
import thridOperate.operate.Car;

import java.util.concurrent.TimeUnit;

/**对汽车进行冲水
* Created by acer on 2016/2/29.
*/
public class WaterCar implements Runnable {

private Car car;

public WaterCar(Car car) {
this.car = car;
}

@Override
public void run() {
while (!Thread.interrupted()) {
car.wateron();
car.watiforDry();
try {
TimeUnit.MILLISECONDS.sleep(100);
PrintUtil.priintall("Water is finish \n");
} catch (InterruptedException e) {
PrintUtil.priintall("Exit via interrupt \n");
return;
}
}
PrintUtil.priintall("Task is end");
}
}

测试是否正常运行，打印相关的信息：

package thridOperate.operate;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
* Created by acer on 2016/2/29.
*/
public class TestOperate {

public static void main(String args[]) throws InterruptedException {
Car c = new Car();
ExecutorService service = Executors.newCachedThreadPool();
WaterCar waterCar = new WaterCar(c);
DryCar dryCar = new DryCar(c);
service.execute(waterCar);
service.execute(dryCar);
TimeUnit.SECONDS.sleep(5);
service.shutdownNow();

}
}

2,错失的信号：

原因：当两个线程使用notify()和notify()进行协作时，有时会错过某个信号。

解决方案，对控制的唤醒条件进行同步锁，防止错位访问

错误代码code：

T1:

synchronized(shareMonitor) {
<set codition for T2>
shareMonitor.notify();
}

T2:

While(someConditon) {
synchronized(shareMonitor){
wait();
}
}

执行过程中T1已将条件进行变化，符合T2执行的条件，但由于T2可能在这之前已进入while循环里面，导致进入等待状态，错失信号。

解决方法，修改T2部分代码

T2：

synchronized(shareMonitor){
While(someConditon) {
wait();
}
}

3，notify和notifyAll

1)使用notifyall比使用notify更安全

2）使用notify是对notifyall的优化，因为使用notify只会唤醒一个任务。在使用过程中，必须保证被唤醒的任务是恰当的任务。因此使用notiy必须满足一下条件，缺一不可

① 所有任务等待的条件相同

②当条件发生变化时，只能有一个任务受益

③对所有存在的子类都起作用。，

不满足以上条件，只能使用notifyall,它只会唤醒等待这个锁的任务，而不是所有的任务

4，生产者和消费者模式：

1）基本模式：customModel包

5，生产者和消费者队列

标准库提供的接口：java.util.concurrent.BlockingQueue

具体：LinkedBlockingQueue

ArrayBlockingQueue

代码这里就不贴了，所有代码在这里都可以找到 这里写链接内容