Java多线程学习：（wait,notify）--(await,signal)--(park,unpark)

前置Java多线程学习知识点：https://www.cnblogs.com/gzhcsu/p/7674894.html

本文主要对Java.util.concurrent中锁的相关对比学习。

他们分别是：

① Object中wait和notify;

② Lock中lock.newCondition:condition.await()和condition.signal();

③  LockSupport中静态方法park和unpark;

一、先上结论：

① 对于Object中wait和notify：必须在锁中使用，这里指synchronized，并且wait方法要先于notify，否则wait方法会一直阻塞该该线程。

② Lock中lock.newCondition:condition.await()和condition.signal()：必须在锁中使用，这里指lock.lock()之后，并且await方法要先于singnal，否则await方法会一直阻塞该该线程。

③ LockSupport优势，优势1：不需要再锁中进行；优势二：park方法可以不先于unpark方法。

二、测试代码

public class LockAQS {
    private static Object objectLock = new Object();
    private static Lock lock = new ReentrantLock();


    public static void main(String[] args) {
//        testWaitAndNotify();
//        testLockAndUnLock();
        testParkAndUnPark();
    }

    static void testParkAndUnPark(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "	" + "come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "	 " + "被唤醒");
        });
        t1.start();
        
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "	 " + "通知其他");
            LockSupport.unpark(t1);
        }).start();

    }

    static void testLockAndUnLock() {
        Condition condition = lock.newCondition();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + "	" + " come in");
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "	 " + "被唤醒");
            } finally {
                lock.unlock();
            }
        }, "LockA").start();

        new Thread(() -> {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "	 " + "通知其他");
                condition.signal();
            } finally {
                lock.unlock();
            }
        }, "LockB").start();
    }

    static void testWaitAndNotify() {
        new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "	" + "come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "	 " + "被唤醒");
            }
        }, "A").start();

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "	" + "通知其他");
                objectLock.notify();
            }
        }, "B").start();
    }
}

 三、分析LockSupport

① 类源码说明：park阻塞当前线程，unpark发放许可证，不同于Semaphores，许可证不可累加计算，至多一个。

/**
 * Basic thread blocking primitives for creating locks and other
 * synchronization classes.
 *
 * <p>This class associates, with each thread that uses it, a permit
 * (in the sense of the {@link java.util.concurrent.Semaphore
 * Semaphore} class). A call to {@code park} will return immediately
 * if the permit is available, consuming it in the process; otherwise
 * it <em>may</em> block.  A call to {@code unpark} makes the permit
 * available, if it was not already available. (Unlike with Semaphores
 * though, permits do not accumulate. There is at most one.)

② LockSupport.parK()方法：阻塞现场直到右许可证。

    /**
     * Disables the current thread for thread scheduling purposes unless the
     * permit is available.
     * ...
     */
    public static void park() {
        UNSAFE.park(false, 0L);
    }

③ upark方法，给指定的线程发放许可证。

    /**
     * Makes available the permit for the given thread, if it
     * was not already available.  If the thread was blocked on
     * {@code park} then it will unblock.  Otherwise, its next call
     * to {@code park} is guaranteed not to block. This operation
     * is not guaranteed to have any effect at all if the given
     * thread has not been started.
     *
     * @param thread the thread to unpark, or {@code null}, in which case
     *        this operation has no effect
     */
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }