关于线程中的通信问题。 - 黑马程序员技术交流社区

package com.yellow.chapteOne;
public class Test {
private static int n = 0;
private static boolean flag = true;
public static void main(String[] args) {
final Object lock = new Object();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
while (true) {
if (flag != true) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 5; i++) {
System.out.println(n++);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = false;
lock.notify();
}
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
while (true) {
if (flag != false) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 0; i < 5; i++) {
System.out.println(n--);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
flag = true;
lock.notify();
}
}
}
});
thread1.start();
thread2.start();
}
}

复制代码

/**
* The current thread must own this object's monitor. The thread 当前线程必须拥有这个对象的monitor
* releases ownership of this monitor and waits until another thread 并且释放自己对monitor的所属权
* notifies threads waiting on this object's monitor to wake up 直到另一个线程执行notifies 或者 notifyAll
* either through a call to the <code>notify</code> method or the
* <code>notifyAll</code> method. The thread then waits until it can 这个线程会一直等待直到重新获得monitor的所有权然后继续执行
* re-obtain ownership of the monitor and resumes execution.
*
* As in the one argument version, interrupts and spurious wakeups are
* possible, and this method should always be used in a loop: 正是因为执行这个方法的前提是必须获得monitor

复制代码

/**
* Wakes up a single thread that is waiting on this object's 唤醒其他在等这个对象的monitor的线程
* monitor. If any threads are waiting on this object, one of them 如果有很多线程都在等这个monitor，随机选一个~~
* is chosen to be awakened. The choice is arbitrary and occurs at 好吧，所以这很不科学，想唤醒所有的线程，请用notifyAll
* the discretion of the implementation. A thread waits on an object's
* monitor by calling one of the <code>wait</code> methods.
*
* 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.
*
* 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</code> statement
* that synchronizes on the object.
* <li>For objects of type <code>Class,</code> by executing a
* synchronized static method of that class.
* </ul>
*
* Only one thread at a time can own an object's monitor.
*
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @see java.lang.Object#notifyAll()
* @see java.lang.Object#wait()
*/

复制代码

/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread 没有失去monitors的所有权
* does not lose ownership of any monitors.
*
* @param millis the length of time to sleep in milliseconds.
* @exception InterruptedException if any thread has interrupted
* the current thread. The interrupted status of the
* current thread is cleared when this exception is thrown.
* @see Object#notify()
*/
public static native void sleep(long millis) throws InterruptedException;

复制代码