notify
public final void notify()
唤醒正在此对象监视器上等待的单个线程。如果有任何线程正在等待这个对象，则选择其中一个线程被唤醒。选择是任意的，由实现决定。线程通过调用一个等待方法来等待对象的监视器。
被唤醒的线程将无法继续，直到当前线程释放该对象上的锁。被唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能正在积极地竞争同步该对象;例如，在成为下一个锁定此对象的线程时，被唤醒的线程没有可靠的特权或劣势。
此方法只能由该对象监视器的所有者线程调用。线程通过以下三种方式之一成为对象监视器的所有者:
①通过执行该对象的同步实例方法。
②通过执行对对象进行同步的同步语句的主体。
③对于类类型的对象，通过执行该类的同步静态方法。
public final native void notifyAll()
唤醒正在此对象监视器上等待的所有线程。线程通过调用一个wait方法来等待对象的监视器。
被唤醒的线程将无法继续，直到当前线程释放该对象上的锁。被唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能正在积极地竞争对该对象进行同步;例如，在成为下一个锁定此对象的线程时，被唤醒的线程没有可靠的特权或劣势。
此方法只能由该对象监视器的所有者线程调用。有关线程如何成为监视器所有者的描述，请参阅notify方法。
关于wait与notify和notifyAll方法的总结
- 当调用wait时，首先需要确保调用了wait方法的线程已经持有了对象的锁。
- 当调用wait后，该线程就会释放掉这个对象的锁，然后进入到等待状态（wait set）
- 当线程调用了wait后进入到等待状态时，它就可以等待其他线程调用相同对象的notify或者notifyAll方法来使得自己被唤醒。
- 一旦这个线程被其他线程唤醒后，该线程就会与其他线程一同开始竞争这个对象的锁（公平竞争）；只有当该线程获取到了这个对象的锁后，线程才会继续往下执行。
- 调用wait方法的代码片段需要放在一个synchronized块或是synchronized方法中，这样才可以确保线程在调用wait方法前已经获取到了对象的锁。
- 当调用对象的notify方法时，它会随机唤醒该对象等待集合（wait set）中的任意一个线程，当某个线程被唤醒后，他就会与其他线程一同竞争对象的锁。
- 当调用对象的notifyAll方法时，它会唤醒该对象等待集合（wait set）中的所有线程，这些线程被唤醒后，又会开始竞争对象的锁。
- 在某一时刻，只有唯一一个线程可以拥有对象的锁。
示例
public class Test {
public synchronized void method1(){}
public synchronized void method2(){}
}
Q: Test test = new Test(),创建了唯一对象，当某一个线程A调用了该类的method1方法（此方法并未执行完），另一个线程B是否可以调用该类的method2方法？
A：当然不可以，对于同一个对象来说，它的所有的synchronized方法锁的对象是一个东西。
Q:如果创建了两个对象，某一个线程调用了第一个对象的method1方法时（此方法并未执行完），另一个线程是否可以调用第二个对象的mehtod2方法？
A：当然可以，这两个对象各自有一把锁，这两个对象没有什么关系。
Q:修改public synchronized void method2(){}为public static synchronized void method2(){}, Test test = new Test(),创建了唯一对象，当某一个线程A调用了该类的method1方法（此方法并未执行完），另一个线程B是否可以调用该类的method2方法？
A:当然可以，第一个方法锁的是当前对象，第二方法锁是当前对象所对应的class对象
题目：编写一个多线程程序，实现这样一个目标：
1.存在一个对象，该对象有一个int类型的成员变量counter，该成员变量的初始值为0。
2.创建两个线程，其中一个线程堆该对象的成员变量counter增1，另一个线程对该对象的成员变量减1.
3.输出该对象成员变量counter每次变化后的值。
4.最终输出的结果应为：1010101010...
package com.leofight.concurrency1;
public class MyObject {
private int counter;
public synchronized void increase(){
if (counter != 0 ){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
counter++;
System.out.println(counter);
notify();
}
public synchronized void decrease(){
if (counter == 0 ){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
counter--;
System.out.println(counter);
notify();
}
}
package com.leofight.concurrency1;
public class IncreaseThread extends Thread {
private MyObject myObject;
public IncreaseThread(MyObject myObject){
this.myObject = myObject;
}
@Override
public void run() {
for (int i = 0; i <30; ++i){
try {
Thread.sleep((long) (Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
myObject.increase();
}
}
}
package com.leofight.concurrency1;
public class DecreaseThread extends Thread {
private MyObject myObject;
public DecreaseThread(MyObject myObject){
this.myObject = myObject;
}
@Override
public void run() {
for (int i = 0; i <30; ++i){
try {
Thread.sleep((long) (Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
myObject.decrease();
}
}
}
package com.leofight.concurrency1;
public class Client {
public static void main(String[] args) {
MyObject myObject = new MyObject();
Thread increaseThread = new IncreaseThread(myObject);
Thread decreaseThread = new DecreaseThread(myObject);
increaseThread.start();
decreaseThread.start();
}
}
如果启动多个增加线程、多个减少线程，上述程序会出错，该如果修改呢？
修改代码如下,即可正常输出。
package com.leofight.concurrency1;
public class MyObject {
private int counter;
public synchronized void increase(){
while (counter != 0 ){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
counter++;
System.out.println(counter);
notify();
}
public synchronized void decrease(){
while (counter == 0 ){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
counter--;
System.out.println(counter);
notify();
}
}
