JavaScript／Java实现阻塞线程的一个方法

2019-01-06

JavaScript和Java实现阻塞线程的一个方法

一：JavaScript

我们有时候会使用JavaScript开发跨平台的App，在某些特定场景下，我们希望在某个singleton量未达到预期时，多个线程中指定线程处于等待状态。当然我们也不能使用JavaScript的while死循环来解决问题，很显然，如果等待状态持续时间较长，死循环会在当前线程中调动cpu带来灾难性的性能开销。

于是，这里分享一个实现思路，使用ES6的语法和递归，可以让特定的多线程处于等待，同时只会产生极低的性能开销。


wx.utils.await = async o=>{
    return new Promise((resolve, reject) => {
      setTimeout(async function () {
        console.log('阻塞锁...............' + wx.userconfig.poll_lock);
        console.log('重复提交锁...............' + wx.userconfig.on_lock);
        if (wx.userconfig.poll_lock == false) {
          resolve(wx.userconfig.poll_lock);
          return;
        }
        // resolve(wx.userconfig.poll_lock);
        // return;
       let r = await wx.utils.await(o);
        if (wx.userconfig.poll_lock == false){
          resolve(wx.userconfig.poll_lock)
         return;
       }
      }, 1000);
    })
    
  }

二：Java

JDK中集成了相关自旋的方法，以使用很低的性能开销实现线程的等待，相关实现如下

public class ExeUtils {
    private ExeUtils() {
    }
    private ExecutorService exe;

    private ExecutorService getExe() {
        return exe;
    }

    private ExeUtils setExe(ExecutorService exe) {
        this.exe = exe;
        return this;
    }

    public static void go(Runnable runnable) {
        ExeUtils eu = new ExeUtils().setExe(Executors.newSingleThreadExecutor());
        eu.getExe().submit(runnable);
        eu.shutdown();
    }
    public static void go(Callable<Object> callable) {
        ExeUtils eu = new ExeUtils().setExe(Executors.newSingleThreadExecutor());
        eu.getExe().submit(callable);
        eu.shutdown();
    }

    private void shutdown() {
        try {
            System.out.println("try to shut down【"+exe+"】");
            exe.shutdown();
        } catch (Exception  e) {
            e.printStackTrace();
        }finally {
            try {
                if(!exe.awaitTermination(10,TimeUnit.SECONDS)){
                    System.out.println("10秒检测器");
                    if(!exe.isTerminated()){
                        System.out.println("【"+exe+"】超时未关闭");
                        exe.shutdownNow();
                        System.out.println("【"+exe+"】被强制关闭");
                    }

                }else{
                    System.out.println("【"+exe+"】已被正确关闭啦");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
                exe.shutdownNow();
            }

        }
    }

}

public Runnable testThread(Map testObj) {
        Runnable r = () -> {
            System.out.println("异步线程原来的："+testObj.getString("is_work"));
//            JDO jdo = new JDO();
            try {
                Thread.sleep(5000);
                testObj.set("is_work","2");
                System.out.println("异步线程set后的："+testObj.getString("is_work"));
//                jdo.update(testObj);
            } catch (Exception e) {
                e.printStackTrace();
//                jdo.rollbackAll();
            }finally {
//                jdo.close();
            }
//            System.out.println("原来的："+testObj);
        };
        return r;
    }

public void testThreadMethod(){

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lockInterruptibly();
            Map t = new HashMap();
            ExeUtils.go(testThread(t));
            while (t.getString("is_work").equals("1")){
                    lock.newCondition().await();
                }
            System.out.println(t.getString("is_work"));
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

以上，新年快乐。