java锁之wait,notify(wait会释放锁，notify仅仅只是通知，不释放锁)

wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放），调用wait方法的一个或多个线程就会解除wait状态，重新参与竞争对象锁，程序如果可以再次得到锁，就可以继续向下运行。

1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

　2）当前线程必须拥有此对象的monitor（即锁），才能调用某个对象的wait()方法能让当前线程阻塞，

（这种阻塞是通过提前释放synchronized锁，重新去请求锁导致的阻塞，这种请求必须有其他线程通过notify()或者notifyAll（）唤醒重新竞争获得锁）

　3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；

（notify()或者notifyAll()方法并不是真正释放锁，必须等到synchronized方法或者语法块执行完才真正释放锁）

　4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程，唤醒的线程获得锁的概率是随机的，取决于cpu调度

例子1（错误使用导致线程阻塞）：三个线程，线程3先拥有sum对象的锁，然后通过sum.notify()方法通知等待sum锁的线程去获得锁，但是这个时候线程1,2并没有处于wait()导致的阻塞状态，而是在synchronized方法块处阻塞了，所以，这次notify()根本没有通知到线程1,2。然后线程3正常结束，释放掉sum锁，这个时候，线程1就立刻获得了sum对象的锁（通过synchronized获得），然后调用sum.wait()方法释放掉sum的锁，线程2随后获得了sum对象的线程锁（通过synchronized获得），这个时候线程1,2都处于阻塞状态，但是悲催的是，这之后再也没有线程主动调用sum.notify()或者notifyAll()方法显示唤醒这两个线程，所以程序阻塞

1. public class CyclicBarrierTest {
2. public static void main(String[] args) throws Exception {
3. final Sum sum=new Sum();
4. new Thread(new Runnable() {
5. @Override
6. public void  run() {
7. try {
8. synchronized (sum) {
9. System.out.println("thread3 get lock");
10. sum.sum();
11. sum.notifyAll(); //此时唤醒没有作用，没有线程等待
12. Thread.sleep(2000);
13. System.out.println("thread3 really release lock");
14. }
15. } catch (Exception e) {
16. e.printStackTrace();
17. }
18. }
19. }).start();
20. new Thread(new Runnable() {
21. @Override
22. public void  run() {
23. try {
24. synchronized (sum) {
25. System.out.println("thread1 get lock");
26. sum.wait();//主动释放掉sum对象锁
27. System.out.println(sum.total);
28. System.out.println("thread1 release lock");
29. }
30. } catch (Exception e) {
31. e.printStackTrace();
32. }
33. }
34. }).start();
35. new Thread(new Runnable() {
36. @Override
37. public void  run() {
38. try {
39. synchronized (sum) {
40. System.out.println("thread2 get lock");
41. sum.wait();  //释放sum的对象锁，等待其他对象唤醒（其他对象释放sum锁）
42. System.out.println(sum.total);
43. System.out.println("thread2 release lock");
44. }
45. } catch (Exception e) {
46. e.printStackTrace();
47. }
48. }
49. }).start();
50. }
51. }
52. class Sum{
53. public Integer total=0;
54. public void  sum() throws Exception{
55. total=100;
56. Thread.sleep(5000);
57. }
58. }

运行结果：

1. thread3 get lock
2. thread3 really release lock
3. thread2 get lock
4. thread1 get lock
5. //程序后面一直阻塞

例子2：还是上面程序，顺序不同，把线程3放到最下面。最后线程1,2都因为没有再次获得线程导致线程阻塞

运行过程：

线程1先运行获得sum对象锁（通过synchronized），但是随后执行了sum.wait()方法，主动释放掉了sum对象锁，然后线程2获得了sum对象锁（通过synchronized）,也通过sum.wait()失去sum的对象锁，最后线程3获得了sum对象锁（通过synchronized），主动通过sum.notify()通知了线程1或者2，假设是1，线程1重新通过notify()/notifyAll()的方式获得了锁，然后执行完毕，随后线程释放锁，然后这个时候线程2成功获得锁，执行完毕。

1. public class CyclicBarrierTest {
2. public static void main(String[] args) throws Exception {
3. final Sum sum=new Sum();
4. new Thread(new Runnable() {
5. @Override
6. public void  run() {
7. try {
8. synchronized (sum) {
9. System.out.println("thread1 get lock");
10. sum.wait();//主动释放sum对象锁，等待唤醒
11. System.out.println(sum.total);
12. System.out.println("thread1 release lock");
13. }
14. } catch (Exception e) {
15. e.printStackTrace();
16. }
17. }
18. }).start();
19. new Thread(new Runnable() {
20. @Override
21. public void  run() {
22. try {
23. synchronized (sum) {
24. System.out.println("thread2 get lock");
25. sum.wait();  //主动释放sum对象锁，等待唤醒
26. System.out.println(sum.total);
27. System.out.println("thread2 release lock");
28. }
29. } catch (Exception e) {
30. e.printStackTrace();
31. }
32. }
33. }).start();
34. new Thread(new Runnable() {
35. @Override
36. public void  run() {
37. try {
38. synchronized (sum) {
39. System.out.println("thread3 get lock");
40. sum.sum();
41. sum.notifyAll();//唤醒其他等待线程（线程1,2）
42. Thread.sleep(2000);
43. System.out.println("thread3 really release lock");
44. }
45. } catch (Exception e) {
46. e.printStackTrace();
47. }
48. }
49. }).start();
50. }
51. }
52. class Sum{
53. public Integer total=0;
54. public void  sum() throws Exception{
55. total=100;
56. Thread.sleep(5000);
57. }
58. }

执行结果：

1. thread1 get lock
2. thread2 get lock
3. thread3 get lock
4. thread3 really release lock
5. 100
6. thread2 release lock
7. 100
8. thread1 release lock

转自 https://blog.csdn.net/azhegps/article/details/63031562