使用Object

package study;

public class Test {
	public static void main(String[] args) throws InterruptedException {
		Object lock = new Object();
		Thread t1 = new Thread(() -> {
			System.out.println("进入线程t1");
			synchronized (lock) {
				System.out.println("线程t1准备进入等待状态");
				try {
					lock.wait();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程t1撤出了");
		});
		t1.start();
		Thread.sleep(1000);
		System.out.println("主线程休眠完毕,准备唤醒t1线程");
		synchronized (lock) {
			lock.notify();
		}
	}
}

使用Condition

package study;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test1 {
	static ReentrantLock lock = new ReentrantLock(); 
	static Condition condition = lock.newCondition();
	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			lock.lock();
			System.out.println("线程t1开始执行");
			try {
				try {
					System.out.println("线程t1在condition上等待");
					condition.await();
				} catch (Exception e) {
					e.printStackTrace();
				}
			} finally {
				lock.unlock();
			}
			System.out.println("线程t1执行完毕");
		});
		t1.start();
		System.out.println("主线程执行中");
		try {
			lock.lock();
			System.out.println("主线程准备唤醒t1线程");
			condition.signal();
		} finally {
			lock.unlock();
		}
	}
}

使用lockSupport

package study;
import java.util.concurrent.locks.LockSupport;


public class Test2 {
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread(() -> {
			System.out.println("线程t1开始执行");
			System.out.println("准备使用lockSupport让t1线程等待");
			LockSupport.park();
			System.out.println("线程t1结束等待,执行完毕");
		});
		t1.start();
		System.out.println("主线程准备睡眠2秒");
		Thread.sleep(2000);
		System.out.println("主线程睡眠完毕,准备唤醒t1线程");
		LockSupport.unpark(t1);
	}
}

3种方式的区别

三种让线程等待和唤醒的方法：

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程：

第一种方式：synchronized + wait + notify：

使用Object中的wait方法让线程等待，使用Object中的notify方法唤醒线程：

代码演示：

package com.fan.waitnotify;

public class SyncDemo {
    //定义锁
    static Object obj = new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized (obj){//加锁
                System.out.println(Thread.currentThread().getName()+
                        "\t ----come  in---");
                try {
                    obj.wait();//同一个锁去等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+
                        "被唤醒--");
            }
        },"A线程").start();

        //
        new Thread(()->{
            synchronized (obj){
                obj.notify();//同一个锁去唤醒
                System.out.println(Thread.currentThread().getName()+
                        "\t ---通知其他线程---");
            }
        },"B线程").start();
    }
}

存在的弊端：

问题一：wait和notify 不能脱离synchronized代码块或者synchronized方法独自运行

报异常，证明 wait + notify不能脱离synchronized 代码块或者方法。

问题二：wait + notify顺序不能颠倒，只能先等待后唤醒。

打印结果：发现处于阻塞状态：

被阻塞的结果，证明wait + notify顺序不能颠倒，只能先等待后唤醒。等待中的线程才能被唤醒，否则无法被唤醒。

第二种方式：Lock + await + signal ：

使用JUC包中的Condition的await方法让线程等待，使用signal方法唤醒线程：

代码演示：

package com.fan.waitnotify;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    //创建可重入的非公平锁
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();
    public static void main(String[] args) {
        //如果这个方法我们只想运行一次，则直接写到线程内
        new Thread(()->{
            lock.lock();//加锁
            try {
                System.out.println(Thread.currentThread().getName()+
                        "\t -----进来了----");
                try {
                    condition.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //
                System.out.println(Thread.currentThread().getName()+
                        "\t -----被唤醒----");
            } finally {
                lock.unlock();//解锁
            }
        },"A").start();

        new Thread(()->{
            lock.lock();
            try {
                condition.signal();//唤醒
                System.out.println(Thread.currentThread().getName()+
                        "\t -----通知其他线程----");
            } finally {
                lock.unlock();
            }
        },"B").start();
    }
}

存在的问题：

问题一：lock和await和signal必须一起使用才行，await和signal不能脱离lock单独使用；

出现异常：证明lock和await和signal必须一起使用才行；

问题二：必须要先等待，后唤醒；调换顺序不能正常运行；

同样存在问题：必须要先等待，后唤醒；

总结：传统的synchronized 和Lock实现等待唤醒通知的约束：

第三种方式：LockSupport + park +unpark :

即LockSupport类的park方法可以 阻塞当前线程,使用unpark 方法唤醒指定被阻塞的线程：

注意：
park相当于wait,unpark相当于notify

LockSupport是什么：

park方法：

unpark方法：

代码演示：

package com.fan.waitnotify;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
public class ParkDemo {
    public static void main(String[] args) {
        Thread A = new Thread(()->{
            //测试  先通知后阻塞：
            /*try { TimeUnit.SECONDS.sleep(3);}
            catch (InterruptedException e) {e.printStackTrace();}*/
            System.out.println(Thread.currentThread().
                    currentThread().getName()+"\t ----进来了----");
            LockSupport.park();//当前线程被阻塞
            System.out.println(Thread.currentThread().
                    currentThread().getName()+"\t ----被唤醒----");
        },"A");
        A.start();
        //让A线程先运行
        try { TimeUnit.SECONDS.sleep(1);}
        catch (InterruptedException e) {e.printStackTrace();}
        Thread B = new Thread(() -> {
            LockSupport.unpark(A);//唤醒 被阻塞的 线程实例
            System.out.println(Thread.currentThread().
                    currentThread().getName()+"\t ----通知了----");
        }, "B");
        B.start();
    }
}

测试 先通知后阻塞：发现可以正常运行；

重点：

LockSupport面试题：

Object中的wait()、notify()让线程等待和唤醒

Object.wait()、Object.notify()方法必须再synchronized修饰的代码块中才能正常使用，否则会报异常(语法不会显示有错误)

如下如果注释synchronized (obj)会报java.lang.IllegalMonitorStateException: current thread is not owner

正常使用必须在synchronized中使用！

public static void main(String[] args) {
    Object obj = new Object();
    new Thread(() -> {
       // synchronized (obj) {
            System.out.println(Thread.currentThread().getName() + "\t======== 进入");
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t======== 被唤醒");
       // }
    }, "A").start();

    new Thread(() -> {
        //synchronized (obj) {
            obj.notify();
            System.out.println(Thread.currentThread().getName()+"\t============ 通知");
        //}
    }, "B").start();
}

Condition中的await()、signal()让线程等待和唤醒

Condition需要在ReentrantLock下使用，也就是需要上锁和释放锁，否则也会报java.lang.IllegalMonitorStateException

public static void main(String[] args) {
    ReentrantLock lock = new ReentrantLock();
    Condition condition=lock.newCondition();

    new Thread(() -> {
//            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t======== 进入");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
//                    lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "\t======== 被唤醒");
    }, "A").start();

    new Thread(() -> {
//            lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName()+"\t============ 通知");
        } finally {
//                lock.unlock();
        }
    }, "B").start();
}

LockSupport中的park()、unpark()

LockSupport调用unpark方法最多只发放一个许可证，调用park则需要消耗一个许可证。
换而言之

如下的逻辑虽然调用了两次unpark，但LockSupport只发放一个许可证

LockSupport.unpark(t1)//需要传入参数线程t1
LockSupport.unpark(t1)//需要传入参数线程t1
LockSupport.park()
LockSupport.park()// 线程会阻塞

另外LockSupport.park()和LockSupport.unpark()不影响正常使用阻塞

LockSupport.unpark(t1)//需要传入参数线程t1
LockSupport.park()
// 上面的顺序和下面的调用顺序，两者的作用相同
LockSupport.park()
LockSupport.unpark(t1)//需要传入参数线程t1

总而概之，LockSupport是一个线程阻塞的工具类，里面的所有方法都是静态的

相关文章：

1、LockSupport源码的简化

2、LockSupport中文文档