线程之间的协作

package org.dance.day1.wn;

/**
 * 快递实体类
 *
 * @author ZYGisComputer
 */
public class Express {

    public final static String CITY = "ShangHai";

    /**
     * 快递运输的里程数
     */
    private int km;

    /**
     * 快递到达的地点
     */
    private String site;

    public Express() {
    }

    public Express(int km, String site) {
        this.km = km;
        this.site = site;
    }

    /**
     * 变化公里数:然后通知处于wait状态并需要处理公里数的线程进行业务处理
     */
    public synchronized void checkKm() {
//      变化公里数
        this.km = 101;
//      全部通知
        notifyAll();
    }

    /**
     * 变化地点:然后通知处于wait状态并需要处理地点的线程进行业务处理
     */
    public synchronized void checkSite() {
//        变化城市
        this.site = "BeiJin";
//         全部通知
        notifyAll();
    }

    public synchronized void waitKm() {
        // 循环等待
        while (this.km <= 100) {
            try {
                wait();
                System.out.println("check km " + Thread.currentThread().getId());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("the km is " + this.km + ", I will change DB.");
    }

    public synchronized void waitSite() {
        // 循环等待
        while (CITY.equals(this.site)) {
            try {
                wait();
                System.out.println("check site " + Thread.currentThread().getId());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("the site is " + this.site + ", I will change DB.");
    }
}

package org.dance.day1.wn;

import org.dance.tools.SleepTools;

/**
 * 测试wait notify/notifyAll
 * @author ZYGisComputer
 */
public class TestWN {

    private static Express express = new Express(0,Express.CITY);

    /**
     * 检查里程数变化的线程,不满足一直等待
     */
    private static class CheckKm extends Thread{
        @Override
        public void run() {
            express.waitKm();
        }
    }

    /**
     * 检查城市变化的线程,不满足一直等待
     */
    private static class CheckSite extends Thread{
        @Override
        public void run() {
            express.waitSite();
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new CheckKm().start();
        }
        for (int i = 0; i < 3; i++) {
            new CheckSite().start();
        }
        SleepTools.second(1);
        // 修改里程数
        express.checkKm();
    }
}

check site 16
check site 15
check site 14
check km 13
the km is 101, I will change DB.
check km 12
the km is 101, I will change DB.
check km 11
the km is 101, I will change DB.

check km 11
the km is 101, I will change DB.

check site 11

/**
     * Wakes up a single thread that is waiting on this object‘s
     * monitor. If any threads are waiting on this object, one of them
     * is chosen to be awakened. The choice is arbitrary and occurs at
     * the discretion of the implementation. A thread waits on an object‘s
     * monitor by calling one of the {@code wait} methods.
     * <p>
     * The awakened thread will not be able to proceed until the current
     * thread relinquishes the lock on this object. The awakened thread will
     * compete in the usual manner with any other threads that might be
     * actively competing to synchronize on this object; for example, the
     * awakened thread enjoys no reliable privilege or disadvantage in being
     * the next thread to lock this object.
     * <p>
     * This method should only be called by a thread that is the owner
     * of this object‘s monitor. A thread becomes the owner of the
     * object‘s monitor in one of three ways:
     * <ul>
     * <li>By executing a synchronized instance method of that object.
     * <li>By executing the body of a {@code synchronized} statement
     *     that synchronizes on the object.
     * <li>For objects of type {@code Class,} by executing a
     *     synchronized static method of that class.
     * </ul>
     * <p>
     * Only one thread at a time can own an object‘s monitor.
     *
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object‘s monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();

The choice is arbitrary and occurs at,the discretion of the implementation.

选择是任意的，发生在，执行的自由裁量权。