LockSupport的park和unpartk

场景：代码中调起线程处理入驻商户，调用上游接口寻找满足入驻条件的商户保存到数据库中。
查询商户的操作须等待同步商户操作完成以后（上游返回）才能返回。即批次校验批次保存。

Merchants - 商户
private String name;
private Integer status;

QueryMerchantThread - 查询商户操作
private int batchNum;//批次号

SynchMerchantThread - 同步商户操作
private Thread currentThread; //传入的线程
//相当于数据库
private List<Merchants> dataList;

public class QueryMerchantThread implements Runnable {
    //批次号
    private int batchNum;

    public QueryMerchantThread(int batchNum) {
        this.batchNum = batchNum;
    }

    @Override
    public void run() {
        //模拟数据库操作，批次号当做该批次报件的商户数
        List<Merchants> merLists = new ArrayList<>();
        for (int i = 0; i < batchNum; i++) {
            if (i % 2 == 0) {
                Merchants merchants = new Merchants("商户" + i, 1);
                merLists.add(merchants);
            } else if (i % 2 == 1) {
                Merchants merchants = new Merchants("商户" + i, 2);
                merLists.add(merchants);
            }
        }
        SynchMerchantThread thmer = new SynchMerchantThread(Thread.currentThread(), merLists);
        Thread mer1 = new Thread(thmer);
        mer1.start();
        LockSupport.park("同步商户");
        //修改商户信息以后的操作
        //删除状态不为0的商户
        for (int i = 0; i < merLists.size(); i++) {
            Merchants merchants = merLists.get(i);
            Integer status = merchants.getStatus();
            if (status.intValue() != 0) {
                merLists.remove(merchants);
            }
        }
        System.out.println(merLists.size());
    }
}

 查询的线程需要等待同步完成以后，才能继续执行。

public class SynchMerchantThread implements Runnable{
    private Thread currentThread;
    //相当于数据库
    private List<Merchants> dataList;

    public SynchMerchantThread(Thread currentThread, List<Merchants> dataList) {
        this.currentThread = currentThread;
        this.dataList = dataList;
    }

    public List<Merchants> getDataList() {
        return dataList;
    }

    public void setDataList(List<Merchants> dataList) {
        this.dataList = dataList;
    }

    public Thread getCurrentThread() {
        return currentThread;
    }

    public void setCurrentThread(Thread currentThread) {
        this.currentThread = currentThread;
    }

    @Override
    public void run() {
       //模拟操作数据库，修改商户状态
        if(dataList.size()>0){
            for (Merchants merchants : dataList) {
                //将状态为2的变更为0
                if(merchants.getStatus().intValue()==2){
                    merchants.setStatus(0);
                }
            }
        }
        try {
            Thread.sleep(2000);
        }catch (Exception e){
            System.out.println(e.getCause());
        }
        System.out.println( LockSupport.getBlocker(currentThread));
        LockSupport.unpark(currentThread);
    }
}

开启两个线程，分别同步两个批次的商户

public class LocFactory {
    public static void main(String[] args) {
       QueryMerchantThread queryMerchantThread = new QueryMerchantThread(800);
        Thread queyThread = new Thread(queryMerchantThread);
        queyThread.start();
        QueryMerchantThread queryMerchantThread2 = new QueryMerchantThread(1000);
        Thread queyThread2 = new Thread(queryMerchantThread2);
        queyThread2.start();
    }
}