Java-LockSupport（四）

旧城等待， 2023-10-13 14:06 10阅读 0赞

#### 1.基本概念 ####

Java的LockSupport类提供了一种基于线程的阻塞和唤醒机制，它可以用于实现线程之间的同步和协作。主要用途包括以下几个方面：

1.  阻塞和唤醒线程：LockSupport类提供了park()和unpark()方法，用于线程的阻塞和唤醒操作。通过调用park()方法，可以使当前线程进入阻塞状态，而unpark()方法则可以唤醒一个被阻塞的线程。相比于传统的synchronized关键字或对象监视器的wait()和notify()方法，LockSupport提供了更灵活、可靠的线程控制方式。
2.  实现线程间的顺序执行：通过适当的使用park()和unpark()方法，可以实现线程之间的顺序执行。例如，在多线程环境下，可以利用LockSupport实现先执行线程A，然后执行线程B，再执行线程C的顺序。
3.  实现线程的阻塞和唤醒条件：LockSupport类提供了一种更为灵活的线程阻塞和唤醒方式。相对于Object类的wait()和notify()方法，LockSupport不需要依赖于特定的对象实例，而是直接操作线程本身。这样可以更方便地实现自定义的线程阻塞和唤醒条件，提供了更大的灵活性。
4.  线程间的通信：LockSupport类可以作为线程间通信的一种方式。通过线程间的阻塞和唤醒操作，可以实现线程之间的信息传递和同步。

需要注意的是，LockSupport类主要用于底层的线程控制和同步，一般情况下不建议直接使用，而是在实现高级并发工具时作为辅助手段使用，例如在Lock、Condition、Semaphore等类的实现中。

LockSupport源码分析

#### 2.类的属性 类的属性 ####

public class LockSupport {
        
        // Hotspot implementation via intrinsics API
        private static final sun.misc.Unsafe UNSAFE;
        // 表示内存偏移地址
        private static final long parkBlockerOffset;
        // 表示内存偏移地址
        private static final long SEED;
        // 表示内存偏移地址
        private static final long PROBE;
        // 表示内存偏移地址
        private static final long SECONDARY;
        
        static {
        
            try {
        
                // 获取Unsafe实例
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                // 线程类类型
                Class<?> tk = Thread.class;
                // 获取Thread的parkBlocker字段的内存偏移地址
                parkBlockerOffset = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("parkBlocker"));
                // 获取Thread的threadLocalRandomSeed字段的内存偏移地址
                SEED = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSeed"));
                // 获取Thread的threadLocalRandomProbe字段的内存偏移地址
                PROBE = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomProbe"));
                // 获取Thread的threadLocalRandomSecondarySeed字段的内存偏移地址
                SECONDARY = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
            } catch (Exception ex) {
         throw new Error(ex); }
        }
    }

说明: UNSAFE字段表示sun.misc.Unsafe类，查看其源码，点击在这里，一般程序中不允许直接调用，而long型的表示实例对象相应字段在内存中的偏移地址，可以通过该偏移地址获取或者设置该字段的值。

#### 3.类的构造函数 ####

// 私有构造函数，无法被实例化
    private LockSupport() {
        }

说明: LockSupport只有一个私有构造函数，无法被实例化。

#### 4.核心函数分析 ####

在分析LockSupport函数之前，先引入sun.misc.Unsafe类中的park和unpark函数，因为LockSupport的核心函数都是基于Unsafe类中定义的park和unpark函数，下面给出两个函数的定义:

public native void park(boolean isAbsolute, long time);
    public native void unpark(Thread thread);

说明: 对两个函数的说明如下:

*  park函数，阻塞线程，并且该线程在下列情况发生之前都会被阻塞: ① 调用unpark函数，释放该线程的许可。② 该线程被中断。③ 设置的时间到了。并且，当time为绝对时间时，isAbsolute为true，否则，isAbsolute为false。当time为0时，表示无限等待，直到unpark发生。
 *  unpark函数，释放线程的许可，即激活调用park后阻塞的线程。这个函数不是安全的，调用这个函数时要确保线程依旧存活。

##### 4.1park函数 #####

park函数有两个重载版本，方法摘要如下

public static void park()；
    public static void park(Object blocker)；

说明: 两个函数的区别在于park()函数没有没有blocker，即没有设置线程的parkBlocker字段。park(Object)型函数如下。

public static void park() {
        
            UNSAFE.park(false, 0L);
    }
    -----------------------------------------------
    public static void park(Object blocker) {
        
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 设置Blocker
        setBlocker(t, blocker);
        // 获取许可
        UNSAFE.park(false, 0L);
        // 重新可运行后再此设置Blocker
        setBlocker(t, null);
    }

`park()`和`park(Object blocker)`是LockSupport类中两个重载的`park()`方法，它们的区别在于`blocker`参数的存在。

1.  `park()`方法：
    
     *  `park()`方法是最简单的形式，没有任何参数。
     *  调用`park()`方法会使当前线程进入阻塞状态，暂停执行。
     *  `park()`方法并不与特定的对象关联，仅用于线程的阻塞和唤醒操作。
     *  在`park()`方法中，没有指定阻塞的原因或关联的对象。
2.  `park(Object blocker)`方法：
    
     *  `park(Object blocker)`方法接受一个`blocker`参数，用于指定阻塞的原因或关联的对象。
     *  `blocker`参数可以是任意对象，用于标识或描述线程的阻塞原因。
     *  当线程被阻塞时，可以通过调用`getBlocker()`方法获取与之关联的`blocker`对象。
     *  `blocker`参数的主要作用是在调试和监测工具中提供更丰富的线程阻塞信息，帮助定位问题。

`blocker`参数在`park(Object blocker)`方法中的作用主要是为了在调试和监测工具中提供更详细的线程阻塞信息，以便于问题的分析和定位。当线程被阻塞时，可以通过监测工具查看线程堆栈信息，以了解线程是因为哪个对象而被阻塞。

需要注意的是，`blocker`参数并不直接参与线程的阻塞和唤醒操作，它只是提供了一种关联信息，方便开发者在调试和监测时进行线程状态的跟踪和分析。在一般情况下，可以使用简单的`park()`方法进行线程的阻塞和唤醒操作，而不需要关注`blocker`参数。

##### 4.2unpark函数 #####

此函数表示如果给定线程的许可尚不可用，则使其可用。如果线程在 park 上受阻塞，则它将解除其阻塞状态。否则，保证下一次调用 park 不会受阻塞。如果给定线程尚未启动，则无法保证此操作有任何效果。具体函数如下:

public static void unpark(Thread thread) {
        
        if (thread != null) // 线程为不空
            UNSAFE.unpark(thread); // 释放该线程许可
    }

说明: 释放许可，指定线程可以继续运行。

#### 5.LockSupport示例说明 ####

##### 5.1使用wait/notify实现线程同步 #####

class MyThread extends Thread {
        
        
        public void run() {
        
            synchronized (this) {
        
                System.out.println("before notify");            
                notify();
                System.out.println("after notify");    
            }
        }
    }
    
    public class WaitAndNotifyDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            MyThread myThread = new MyThread();            
            synchronized (myThread) {
        
                try {
                
                    myThread.start();
                    // 主线程睡眠3s
                    Thread.sleep(3000);
                    System.out.println("before wait");
                    // 阻塞主线程
                    myThread.wait();
                    System.out.println("after wait");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }            
            }        
        }
    }

运行结果

before wait
    before notify
    after notify
    after wait

使用wait/notify实现同步时，必须先调用wait，后调用notify，如果先调用notify，再调用wait，将起不了作用。具体代码如下

class MyThread extends Thread {
        
        public void run() {
        
            synchronized (this) {
        
                System.out.println("before notify");            
                notify();
                System.out.println("after notify");    
            }
        }
    }
    
    public class WaitAndNotifyDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            MyThread myThread = new MyThread();        
            myThread.start();
            // 主线程睡眠3s
            Thread.sleep(3000);
            synchronized (myThread) {
        
                try {
                
                    System.out.println("before wait");
                    // 阻塞主线程
                    myThread.wait();
                    System.out.println("after wait");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }            
            }        
        }
    }

运行结果:

before notify
    after notify
    before wait

执行结果分析：

1.  主线程启动子线程：
    
     *  主线程创建并启动了一个`MyThread`的实例。
     *  子线程开始执行，进入`run()`方法。
2.  子线程执行同步块：
    
     *  子线程进入同步块，输出"before notify"。
     *  子线程调用`notify()`方法，但此时并没有其他线程在等待`myThread`对象的锁。
3.  主线程进入同步块：
    
     *  主线程经过3秒的睡眠后，进入同步块。
     *  主线程输出"before wait"。
     *  主线程调用`myThread.wait()`方法，释放了`myThread`对象的锁，并进入等待状态。
4.  结果分析：
    
     *  主线程进入等待状态后，子线程并没有调用`notify()`方法唤醒等待的线程。
     *  所以在主线程等待期间，没有线程对`myThread`对象进行了通知，因此主线程一直处于等待状态。
     *  因此，输出的结果是"before notify"和"before wait"和“before wait”，而后面的输出语句没有执行。

需要注意的是，在使用`wait()`和`notify()`时，需要保证使用的对象是同一个对象的锁，并且在同步块中进行调用。否则会抛出`IllegalMonitorStateException`异常。在这个示例中，主线程和子线程都使用了`myThread`对象的锁。

##### 5.4使用park/unpark实现线程同步 #####

import java.util.concurrent.locks.LockSupport;
    
    class MyThread extends Thread {
        
        private Object object;
    
        public MyThread(Object object) {
        
            this.object = object;
        }
    
        public void run() {
        
            System.out.println("before unpark");
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            // 获取blocker
            System.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));
            // 释放许可
            LockSupport.unpark((Thread) object);
            // 休眠500ms，保证先执行park中的setBlocker(t, null);
            try {
        
                Thread.sleep(500);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            // 再次获取blocker
            System.out.println("Blocker info " + LockSupport.getBlocker((Thread) object));
    
            System.out.println("after unpark");
        }
    }
    
    public class test {
        
        public static void main(String[] args) {
        
            MyThread myThread = new MyThread(Thread.currentThread());
            myThread.start();
            System.out.println("before park");
            // 获取许可
            LockSupport.park("ParkAndUnparkDemo");
            System.out.println("after park");
        }
    }

运行结果:

before park
    before unpark
    Blocker info ParkAndUnparkDemo
    after park
    Blocker info null
    after unpark

说明: 本程序先执行park，然后在执行unpark，进行同步，并且在unpark的前后都调用了getBlocker，可以看到两次的结果不一样，并且第二次调用的结果为null，这是因为在调用unpark之后，执行了Lock.park(Object blocker)函数中的setBlocker(t, null)函数，所以第二次调用getBlocker时为null。

上例是先调用park，然后调用unpark，现在修改程序，先调用unpark，然后调用park，看能不能正确同步。具体代码如下

import java.util.concurrent.locks.LockSupport;
    
    class MyThread extends Thread {
        
        private Object object;
    
        public MyThread(Object object) {
        
            this.object = object;
        }
    
        public void run() {
        
            System.out.println("before unpark");        
            // 释放许可
            LockSupport.unpark((Thread) object);
            System.out.println("after unpark");
        }
    }
    
    public class ParkAndUnparkDemo {
        
        public static void main(String[] args) {
        
            MyThread myThread = new MyThread(Thread.currentThread());
            myThread.start();
            try {
        
                // 主线程睡眠3s
                Thread.sleep(3000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("before park");
            // 获取许可
            LockSupport.park("ParkAndUnparkDemo");
            System.out.println("after park");
        }
    }

运行结果:

before unpark
    after unpark
    before park
    after park

说明: 可以看到，在先调用unpark，再调用park时，仍能够正确实现同步，不会造成由wait/notify调用顺序不当所引起的阻塞。因此park/unpark相比wait/notify更加的灵活。

#### 6.总结 ####

LockSupport的优点：

1.  灵活性：LockSupport提供了更灵活、直接的线程阻塞和唤醒机制，不需要依赖于特定的对象实例。它可以直接操作线程本身，无需和特定对象关联，更容易控制和管理线程的阻塞和唤醒操作。
2.  无需锁对象：LockSupport不需要和特定的锁对象关联，避免了在等待和唤醒过程中对锁的获取和释放，减少了可能的死锁和竞争条件。
3.  先唤醒后阻塞：LockSupport的park()方法可以先于unpark()方法调用，这意味着可以提前唤醒线程，而不会导致线程永久阻塞。
4.  独立于异常：LockSupport的park()方法不会抛出InterruptedException异常，避免了异常处理的复杂性，可以更方便地在代码中使用。

使用wait/notify的优点：

1.  简单易用：wait()和notify()方法是Java提供的传统线程同步机制，使用起来比较直观和简单，适用于一些简单的同步场景。
2.  阻塞原因和信息传递：wait()和notify()方法可以传递阻塞原因和信息，提供了更多的上下文信息，方便调试和定位问题。
3.  中断处理：wait()方法会抛出InterruptedException异常，并清除中断状态，可以方便地对中断进行处理。

需要注意的是，LockSupport和wait/notify适用于不同的线程同步和通信需求。LockSupport更适合底层的线程控制和同步，而wait/notify适合一些简单的同步场景。在使用它们时需要根据具体的需求和情况进行选择。同时，为了避免竞争条件和死锁等问题，在使用wait/notify时需要谨慎设计和编写同步代码块。