手写一个Callable和FutureTask，异步线程执行并得到结果，了解其原理

一，先模拟源码的Callable创建自己的MyCallable

package com.example.test.demo.thread.callable;
 
public interface MyCallable<T> {
    T call();
}

二，创建自己的FutureTask

package com.example.test.demo.thread.callable;
 
/**
 * 因为要放在Thread中执行，所以要实现Runnable
 */
public class MyFutureTask<T> implements Runnable{
 
    final Object object = new Object();
    private T result;
    private MyCallable<T> callable;
 
    public MyFutureTask(MyCallable<T> callable) {
        this.callable = callable;
    }
 
    @Override
    public void run() {
        result = callable.call();
        // 线程执行完，换新get()方法中等待的线程
        // wait要放在synchronized
        synchronized (object) {
            object.notify();
        }
    }
 
    /**
     * 获取多线程返回值
     * @return 返回多线程执行结果
     */
    public T get () throws InterruptedException {
        // 必须等线程执行完才能返回
        // wait要放在synchronized
        synchronized (object) {
            object.wait();
            return result;
        }
    }
}

三，最后测试

package com.example.test.demo.thread.callable;
import com.example.test.pojo.User;
import java.util.Date;

public class MyCallableDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建callable
        MyCallable<User> callable = new MyCallable<User>() {
            @Override
            public User call() {
                // 模拟执行耗时 3秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return new User("用户" + new Date().getTime(), "29");
            }
        };
        // 2.创建futureTask
        MyFutureTask<User> future = new MyFutureTask<>(callable);
 
        // 3.放到线程中执行
        new Thread(future).start();
        // 4.获取返回结果
        User user = future.get();
        // 5.打印
        System.out.println(user);
    }
}

最后，这里是用wait和notify模拟的，还可以使用LockSupport来实现

LockSupport.park();
LockSupport.unpark();

文章转载自：https://blog.csdn.net/wjy_0208/article/details/118613879

四，（扩展）LockSupport的park()和unpark()的简单使用

concurrent包是基于AQS (AbstractQueuedSynchronizer)框架的，AQS框架借助于两个类：

• Unsafe（提供CAS操作）
• *LockSupport*（提供park/unpark操作）

因此，LockSupport非常重要。

两个重点

（1）操作对象

归根结底，LockSupport.park()和LockSupport.unpark(Thread thread)调用的是Unsafe中的native代码：

//LockSupport中
public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

//LockSupport中
public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

Unsafe类中的对应方法：

    //park
    public native void park(boolean isAbsolute, long time);
    
    //unpack
    public native void unpark(Object var1);

park函数是将当前调用Thread阻塞，而unpark函数则是将指定线程Thread唤醒。

与Object类的wait/notify机制相比，park/unpark有两个优点：

• 以thread为操作对象更符合阻塞线程的直观定义
• 操作更精准，可以准确地唤醒某一个线程（notify随机唤醒一个线程，notifyAll唤醒所有等待的线程），增加了灵活性。

（2）关于“许可”

• 在上面的文字中，我使用了阻塞和唤醒，是为了和wait/notify做对比。

• 其实park/unpark的设计原理核心是“许可”：park是等待一个许可，unpark是为某线程提供一个许可。
  如果某线程A调用park，那么除非另外一个线程调用unpark(A)给A一个许可，否则线程A将阻塞在park操作上。

• 有一点比较难理解的，是unpark操作可以再park操作之前。
  也就是说，先提供许可。当某线程调用park时，已经有许可了，它就消费这个许可，然后可以继续运行。这其实是必须的。考虑最简单的生产者(Producer)消费者(Consumer)模型：Consumer需要消费一个资源，于是调用park操作等待；Producer则生产资源，然后调用unpark给予Consumer使用的许可。非常有可能的一种情况是，Producer先生产，这时候Consumer可能还没有构造好（比如线程还没启动，或者还没切换到该线程）。那么等Consumer准备好要消费时，显然这时候资源已经生产好了，可以直接用，那么park操作当然可以直接运行下去。如果没有这个语义，那将非常难以操作。

• 但是这个“许可”是不能叠加的，“许可”是一次性的。
  比如线程B连续调用了三次unpark函数，当线程A调用park函数就使用掉这个“许可”，如果线程A再次调用park，则进入等待状态。

简单代码实现：

import java.util.concurrent.locks.LockSupport;
 
public class LockTest {
    public static void main(String[] args) {
        Thread A = new Thread(() -> {
            System.out.println("准备阻塞");
            LockSupport.park();
            System.out.println("阻塞完成");
        }, "线程A");
        
        Thread B = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("准备唤醒线程A");
            LockSupport.unpark(A);
        }, "线程B");
        A.start();
        B.start();
    }
}

LockSupport.park()可以被interrupt()方法中断：

    public static void main(String[] args) {
        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                LockSupport.park();
                System.out.println(Thread.interrupted());
            }
        });
        a.start();
//        LockSupport.unpark(a);
        a.interrupt();
    }

执行后结果如下：

文章转载自：https://blog.csdn.net/thetimelyrain/article/details/114587111