iteye_11160
iteye_11160

Jdk1.7 JUC源码增量解析(3)-ForkJoin-非ForkJoin任务的执行过程

Jdk1.7 JUC源码增量解析(3)-ForkJoin-非ForkJoin任务的执行过程

作者：大飞

 

概述：
  • 这篇通过分析一个非ForkJoin(Runnable或者Callable)任务的执行过程来分析ForkJoin的相关代码，注意这里说的非ForkJoin任务实际上也是ForkJoinTask，只是没有分裂(fork)/合并(join)过程。

 

源码分析：
 
       我们看一个非ForkJoin任务的代码示例： 
	public static void main(String[] args) {
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		ForkJoinTask task = forkJoinPool.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("呵呵哒~");
			}
		});
		try {
			task.get();
			forkJoinPool.shutdown();
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
       代码中提交了一个Runnable的任务到ForkJoinPool，任务的执行就是打印一句话。
 
       下面就从提交一个Runnable型的任务到ForkJoinPool，直到任务被执行的过程来分析源码。
  • 首先需要创建一个ForkJoinPool，我们来看下ForkJoinPool的构造方法：

 

    public ForkJoinPool() {
        this(Runtime.getRuntime().availableProcessors(),
             defaultForkJoinWorkerThreadFactory, null, false);
    }
    public ForkJoinPool(int parallelism) {
        this(parallelism, defaultForkJoinWorkerThreadFactory, null, false);
    }
    public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        Thread.UncaughtExceptionHandler handler,
                        boolean asyncMode) {
        checkPermission();
        if (factory == null)
            throw new NullPointerException();
        if (parallelism <= 0 || parallelism > MAX_ID)
            throw new IllegalArgumentException();
        //设置并行度。
        this.parallelism = parallelism;
        //设置工作线程工厂。
        this.factory = factory;
        //设置线程未捕获异常处理器。
        this.ueh = handler;
        //设置是否为异步模式。
        this.locallyFifo = asyncMode;
        /*
         * 参考我们之前介绍的ctl的内容，由于ctl中的AC表示当前活动
         * 工作线程数量减去并行度，所以这里要将这个信息加到ctl上。
         */
        long np = (long)(-parallelism);
        //初始化ForkJoinPool控制信息。
        this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
        //初始化提交任务队列。
        this.submissionQueue = new ForkJoinTask[INITIAL_QUEUE_CAPACITY];
        /*
         * 这里需要根据并行度来算出工作线程数组的大小。
         * 由于数组大小必须的2的幂，这里的算法是算出比
         * parallelism的2倍大的最小的2的幂，但不能超过
         * MAX_ID + 1(1 << 16)的数作为工作线程数组大小
         */
        int n = parallelism << 1;
        if (n >= MAX_ID)
            n = MAX_ID;
        else { // See Hackers Delight, sec 3.2, where n < (1 << 16)
            n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8;
        }
        //创建存放工作线程的数组。
        workers = new ForkJoinWorkerThread[n + 1];
        this.submissionLock = new ReentrantLock();
        this.termination = submissionLock.newCondition();
        //生成工作线程名称前缀。
        StringBuilder sb = new StringBuilder("ForkJoinPool-");
        sb.append(poolNumberGenerator.incrementAndGet());
        sb.append("-worker-");
        this.workerNamePrefix = sb.toString();
    }

 

       细节：
              1.并行度如果未提供，默认就是当前处理器核数。
              2.初始化控制信息的部分，注意在AC和TC的信息上减掉了并行度，比如如果并行度为4，那么初始的AC和TC就都是-4，那么如果后续发现AC等于0，就说明当前活动的线程数正好等于处理器核心数量。
              3.确定工作线程数组大小的过程是这样的，首先取一个数n，默认是并行度的2倍。然后会使用来自HD的一个位操作技巧，就是将n的位模式的前导1后面所有的位都变成1，其实就是一个比n大的2的幂减1的数。当然n最大不能超过MAX_ID，最终数组的大小是n+1，是一个2的幂，能简化后续的取模操作。
 

       ForkJoinPool中还提供了默认的工作线程工厂： 

 

    static {
        ...
        defaultForkJoinWorkerThreadFactory =
            new DefaultForkJoinWorkerThreadFactory();
        ...
    }
    public static interface ForkJoinWorkerThreadFactory {
        public ForkJoinWorkerThread newThread(ForkJoinPool pool);
    }
    static class DefaultForkJoinWorkerThreadFactory
        implements ForkJoinWorkerThreadFactory {
        public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
            return new ForkJoinWorkerThread(pool);
        }
    }
 
 
  • 创建了ForkJoinPool，下面看看将任务提交到Pool方法submit：
    public  ForkJoinTask submit(ForkJoinTask task) {
        if (task == null)
            throw new NullPointerException();
        forkOrSubmit(task);
        return task;
    }

    public  ForkJoinTask submit(Callable task) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask job = ForkJoinTask.adapt(task);
        forkOrSubmit(job);
        return job;
    }

    public  ForkJoinTask submit(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask job = ForkJoinTask.adapt(task, result);
        forkOrSubmit(job);
        return job;
    }

    public ForkJoinTask submit(Runnable task) {
        if (task == null)
            throw new NullPointerException();
        ForkJoinTask job;
        if (task instanceof ForkJoinTask) // avoid re-wrap
            job = (ForkJoinTask) task;
        else
            job = ForkJoinTask.adapt(task, null);
        forkOrSubmit(job);
        return job;
    }

       ForkJoinPool中定义了一些列重载的submit方法，这些submit方法内部会先将Callable、Runnable包装(适配)成ForkJoinTask，然后再进行提交。看下包装的方法： 

    public static  ForkJoinTask adapt(Callable callable) {
        return new AdaptedCallable(callable);
    }
    public static ForkJoinTask adapt(Runnable runnable) {
        return new AdaptedRunnable(runnable, null);
    }

    public static  ForkJoinTask adapt(Runnable runnable, T result) {
        return new AdaptedRunnable(runnable, result);
    }

       针对Callable会包装成一个AdaptedCallable： 

    static final class AdaptedCallable extends ForkJoinTask
        implements RunnableFuture {
        final Callable callable;
        T result;
        AdaptedCallable(Callable callable) {
            if (callable == null) throw new NullPointerException();
            this.callable = callable;
        }
        public T getRawResult() { return result; }
        public void setRawResult(T v) { result = v; }
        public boolean exec() {
            try {
                result = callable.call();
                return true;
            } catch (Error err) {
                throw err;
            } catch (RuntimeException rex) {
                throw rex;
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        }
        public void run() { invoke(); }
        private static final long serialVersionUID = 2838392045355241008L;
    }

       针对Runnable会包装成一个AdaptedRunnable： 

    static final class AdaptedRunnable extends ForkJoinTask
        implements RunnableFuture {
        final Runnable runnable;
        final T resultOnCompletion;
        T result;
        AdaptedRunnable(Runnable runnable, T result) {
            if (runnable == null) throw new NullPointerException();
            this.runnable = runnable;
            this.resultOnCompletion = result;
        }
        public T getRawResult() { return result; }
        public void setRawResult(T v) { result = v; }
        public boolean exec() {
            runnable.run();
            result = resultOnCompletion;
            return true;
        }
        public void run() { invoke(); }
        private static final long serialVersionUID = 5232453952276885070L;
    }

 

 

       所有submit方法内部最终都会调用一个forkOrSubmit方法，看下这个方法： 
    private  void forkOrSubmit(ForkJoinTask task) {
        ForkJoinWorkerThread w;
        Thread t = Thread.currentThread();
        if (shutdown)
            throw new RejectedExecutionException();
        if ((t instanceof ForkJoinWorkerThread) &&
            (w = (ForkJoinWorkerThread)t).pool == this)
            w.pushTask(task);
        else
            addSubmission(task);
    }
       细节：
       如果当前线程是ForkJoin工作线程，说明是在ForkJoinTask内部提交的任务(比如分裂出子任务然后提交执行)，这种情况下会将任务添加到工作线程的任务队列中；如果当前线程不是ForkJoin工作线程，说明是初始提交ForkJoin任务(外部将ForkJoinTask初次提交给ForkJoinPool)，这种情况下会将任务添加到ForkJoinPool的提交任务队列中。
 
       由于我们是初始提交(外部提交任务)，在forkOrSubmit方法中一定会走addSubmission的分支，看下这个方法：   
    private void addSubmission(ForkJoinTask t) {
        final ReentrantLock lock = this.submissionLock;
        lock.lock();
        try {
            ForkJoinTask[] q; int s, m;
            if ((q = submissionQueue) != null) {    // ignore if queue removed
                //这步计算内存偏移地址
                long u = (((s = queueTop) & (m = q.length-1)) << ASHIFT)+ABASE;
                //将t设置到q的对应位置。(LazySet)
                UNSAFE.putOrderedObject(q, u, t);
                queueTop = s + 1;
                if (s - queueBase == m)
                    //如果队列满了，扩展队列。
                    growSubmissionQueue();
            }
        } finally {
            lock.unlock();
        }
        //唤醒工作线程。
        signalWork();
    }
       细节：
       代码可以看到通过Unsafe设置Task到数组的方式，之后所有的设置任务到数组都会采取这种方式，之所以这样做是为了提高性能：这种方式其实和数组原子量(AtomicReferenceArray)中一致，但减少了2方面的性能损耗：1.不用像AtomicReferenceArray内部一样再做边界检测(由外部保证)；2.由于队列最大容量的限制(工作线程中的任务队列也一样)，不用像AtomicReferenceArray一样在计算偏移量过程中不会进行从int到long的提升。
 
       addSubmission中逻辑很清晰：添加一个任务到提交任务队列(过程要加锁)，如果队列满了，扩展一下。然后唤醒工作线程。先看下扩展队列方法：  
    private void growSubmissionQueue() {
        ForkJoinTask[] oldQ = submissionQueue;
        int size = oldQ != null ? oldQ.length << 1 : INITIAL_QUEUE_CAPACITY;
        if (size > MAXIMUM_QUEUE_CAPACITY)
            throw new RejectedExecutionException("Queue capacity exceeded");
        if (size < INITIAL_QUEUE_CAPACITY)
            size = INITIAL_QUEUE_CAPACITY;
        ForkJoinTask[] q = submissionQueue = new ForkJoinTask[size];
        int mask = size - 1;
        int top = queueTop;
        int oldMask;
        if (oldQ != null && (oldMask = oldQ.length - 1) >= 0) {
            for (int b = queueBase; b != top; ++b) {
                long u = ((b & oldMask) << ASHIFT) + ABASE;
                Object x = UNSAFE.getObjectVolatile(oldQ, u);
                if (x != null && UNSAFE.compareAndSwapObject(oldQ, u, x, null))
                    UNSAFE.putObjectVolatile
                        (q, ((b & mask) << ASHIFT) + ABASE, x);
            }
        }
    }
       很容易看懂，最小容量为INITIAL_QUEUE_CAPACITY=8，每次扩展为原来的2倍，最大不能超过MAXIMUM_QUEUE_CAPACITY = 1 << 24(16777216)。
 
  • 现在任务已经提交到ForkJoinPool的submissionQueue中了，那么接下来任务如何被执行呢？继续往下看。
       在addSubmission方法中添加一个Task到Pool的submissionQueue之后，还会执行一个唤醒工作线程的动作，这样就会有工作线程来执行我们提交的任务了，看下唤醒工作线程的方法signalWork：  
    final void signalWork() {
        long c; int e, u;
        while ((((e = (int)(c = ctl)) | (u = (int)(c >>> 32))) &
                (INT_SIGN|SHORT_SIGN)) == (INT_SIGN|SHORT_SIGN) && e >= 0) {
            if (e > 0) {                         
                //唤醒一个等待的工作线程。
                int i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
                     
                if ((ws = workers) == null || //如果看到workers为null
                    (i = ~e & SMASK) >= ws.length || //等待工作线程的下标比workers的size大。
                    (w = ws[i]) == null) //获取不到等待线程。
                    break; 
                long nc = (((long)(w.nextWait & E_MASK)) | //将Treiber stack中下一个等待线程的信息(下标)放到控制信息上。
                           ((long)(u + UAC_UNIT) << 32)); //控制信息上添加一个AC计数。
                if (w.eventCount == e &&
                    UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
                    w.eventCount = (e + EC_UNIT) & E_MASK; //累加w的等待次数。
                    if (w.parked)
                        UNSAFE.unpark(w); //唤醒w。
                    break;
                }
            }
            //添加一个工作线程。
            else if (UNSAFE.compareAndSwapLong
                     (this, ctlOffset, c,
                      (long)(((u + UTC_UNIT) & UTC_MASK) | //累加控制信息上AC和TC。
                             ((u + UAC_UNIT) & UAC_MASK)) << 32)) {
                addWorker(); //添加工作线程。
                break;
            }
        }
    }
        细节：
       首先来看下while里面的条件：(((e = (int)(c = ctl)) | (u = (int)(c >>> 32))) & (INT_SIGN|SHORT_SIGN)) == (INT_SIGN|SHORT_SIGN)    &&     e >= 0
 
       先看下前半部分：当e的第32位bit为1或者u的第32位bit为1 并且 e的第16位bit为1或者u的第16位bit为1，结合上一篇我们了解到的ForkJoinPool中的控制信息可知：
       e的第32位bit为1，说明ST为1，表示当前ForkJoinPool正在关闭。
       u的第32位bit为1，说明AC为负数，表示没有足够多的活动的工作线程。
       e的第16位bit为1，说明ID为负数，表示至少有一个等待线程。
       u的第16位bit为1，说明TC为负数，表示没有足够多的(总的)工作线程。
       再看下前半部分：e >= 0，排除了当前ForkJoinPool正在关闭的情况。
 
       while循环内部由e来区分，当e==0，表示当前没有等待的工作线程，这种情况下要创建一个工作线程；当e>0，说明当前有等待线程，这种情况下唤醒一下等待的工作线程。
 
       按照流程，由于是新创建的Pool，里面还没有工作线程呢，所以signalWork中一定会走添加工作线程的流程了，addWorker方法：  
    private void addWorker() {
        Throwable ex = null;
        ForkJoinWorkerThread t = null;
        try {
            t = factory.newThread(this);
        } catch (Throwable e) {
            ex = e;
        }
        if (t == null) {
            //如果发生了异常导致工作线程创建失败，需要把之前累加的到控制信息的AC和TC计数减回去。
            long c;
            do {} while (!UNSAFE.compareAndSwapLong
                         (this, ctlOffset, c = ctl,
                          (((c - AC_UNIT) & AC_MASK) |
                           ((c - TC_UNIT) & TC_MASK) |
                           (c & ~(AC_MASK|TC_MASK)))));
            // 如果调用来之外部，需要将异常传递出去。
            if (!tryTerminate(false) && ex != null &&
                !(Thread.currentThread() instanceof ForkJoinWorkerThread))
                UNSAFE.throwException(ex);
        }
        else
            t.start(); //创建成功的话，启动工作线程。
    }
       这个方法中要注意下工作线程的创建过程，上面看到Pool会提供了默认的工作线程工厂来创建线程，看下具体过程：  
    static class DefaultForkJoinWorkerThreadFactory
        implements ForkJoinWorkerThreadFactory {
        public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
            return new ForkJoinWorkerThread(pool);
        }
    }
       再看下ForkJoinWorkerThread的构造方法： 
    protected ForkJoinWorkerThread(ForkJoinPool pool) {
        //设置线程名称，名称由Pool的nextWorkerName方法产生。
        super(pool.nextWorkerName());
        //由于ForkJoinWorkerThread中有一个Pool的引用，这里设置引用。
        this.pool = pool;
        //将自己注册到Pool里面。
        int k = pool.registerWorker(this);
        //保存在Pool里面的下标。
        poolIndex = k;
        //这里的eventCount初始化为工作线程在Pool中的下标取反值。
        eventCount = ~k & SMASK;
        //设置工作模式。
        locallyFifo = pool.locallyFifo;
        //设置线程未捕获异常处理器。
        Thread.UncaughtExceptionHandler ueh = pool.ueh;
        if (ueh != null)
            setUncaughtExceptionHandler(ueh);
        //设置为守护线程。
        setDaemon(true);
    }
       工作线程名称的生成方法在Pool中，看下： 
    private volatile int nextWorkerNumber;
    final String nextWorkerName() {
        for (int n;;) {
            if (UNSAFE.compareAndSwapInt(this, nextWorkerNumberOffset,
                                         n = nextWorkerNumber, ++n))
                return workerNamePrefix + n;
        }
    }
       主要看下创建工作线程过程中，注册到Pool的过程： 
    final int registerWorker(ForkJoinWorkerThread w) {
        for (int g;;) {
            ForkJoinWorkerThread[] ws;
            //如果当前scanGuard中没有SG_UNIT标记，尝试设置SG_UNIT标记。
            //这是一个加锁的过程。
            if (((g = scanGuard) & SG_UNIT) == 0 &&
                UNSAFE.compareAndSwapInt(this, scanGuardOffset,
                                         g, g | SG_UNIT)) {
                int k = nextWorkerIndex;
                try {
                    if ((ws = workers) != null) { // ignore on shutdown
                        int n = ws.length;
                        if (k < 0 || k >= n || ws[k] != null) {
                            for (k = 0; k < n && ws[k] != null; ++k)
                                ;
                            if (k == n)
                                ws = workers = Arrays.copyOf(ws, n << 1);
                        }
                        ws[k] = w;
                        nextWorkerIndex = k + 1;
                        int m = g & SMASK;
                        g = (k > m) ? ((m << 1) + 1) & SMASK : g + (SG_UNIT<<1);
                    }
                } finally {
                    scanGuard = g;
                }
                return k;
            }
            else if ((ws = workers) != null) { // help release others
                for (ForkJoinWorkerThread u : ws) {
                    if (u != null && u.queueBase != u.queueTop) {
                        if (tryReleaseWaiter())
                            break;
                    }
                }
            }
        }
    }
        细节：
       registerWorker方法的主要逻辑就是要注册一个工作线程到ForkJoinPool，然后返回工作线程在Pool内部工作线程数组的下标。说明一下：
       1.方法内部的主流程(无限循环)中，首先尝试获取一个顺序锁。如果获取失败，会遍历下所有的工作线程，如果发现有工作线程的任务队列里还有未处理的任务，就会尝试唤醒等待的工作线程，然后再尝试去获取顺序锁。
       2.如果获取顺序锁成功，内部会将传入的工作线程设置到相应的位置(必要的时候工作线程数组需要扩容)，然后返回下标。过程中会调整scanGuard的低16比特。
       注：这里再次分析一下scanGuard这个神奇的域。
              它的高16位用来做顺序锁，我们看到在主流程中首先会查看scanGuard中是否含有SG_UNIT对应的bit信息，如果有说明已经有其他线程持有这个锁了；如果没有，就可以通过一个CAS操作来获取这个锁，获取动作就是给scanGuard上添加上SG_UNIT对应的bit信息，在内部完成逻辑后会清除scanGuard上的SG_UNIT信息。
              它的低16位就像它的命名一样，表示扫描的边界。上面的代码中可以看到，在注册工作线程时候会调整这个边界值，规律是这样，边界值的大小=比当前工作线程最大下标大的最小的2的幂减1(有点绕，不要晕)，举几个栗子：maxIndex=5，guard=7、maxIndex=10，guard=15，看出规律了吧。这个值的作用是为了避免不必要的扫描，因为Pool内部的工作线程数组size可能比较大(初始化的时候就比并行度要大很多，回去看下Pool的构造方法。而且还有可能扩展)，但实际的工作线程数量可能比较小(比如可能数组size是16，但里面只有4个工作线程，14个空位)，如果扫描的时候扫描范围是全部数组，那一定会在空位上浪费很多时间，有了这个guard作为边界(而不是数组的length-1)，会避免这些时间的浪费。
 
       好了，继续我们的流程。前面创建、注册并启动了一个工作线程。接下来，这个工作线程应该会去执行我们提交的任务了吧，继续看ForkJoinWorkerThread的run方法了： 
    public void run() {
        Throwable exception = null;
        try {
            onStart();
            pool.work(this);
        } catch (Throwable ex) {
            exception = ex;
        } finally {
            onTermination(exception);
        }
    }
       ForkJoinWorkerThread的逻辑很明确，启动前回调下onStart方法，然后是主流程(pool.work)，如果方法结束，还会回调下onTermination方法。
       先看下onStart和onTermination： 
    protected void onStart() {
        //初始化工作线程的任务队列。
        queue = new ForkJoinTask[INITIAL_QUEUE_CAPACITY];
        //生成工作线程的种子。
        int r = pool.workerSeedGenerator.nextInt();
        //确保种子不为0。
        seed = (r == 0) ? 1 : r; //  must be nonzero
    }

    protected void onTermination(Throwable exception) {
        try {
            //设置关闭标志。
            terminate = true;
            //取消任务。
            cancelTasks();
            //从ForkJoinPool上注销当前工作线程。
            pool.deregisterWorker(this, exception);
        } catch (Throwable ex) {        // Shouldn't ever happen
            if (exception == null)      // but if so, at least rethrown
                exception = ex;
        } finally {
            if (exception != null)
                UNSAFE.throwException(exception);
        }
    }
      
       下面重点看一下ForkJoinWorkerThread运行过程的主流程-pool.work方法，这个方法定义在ForkJoinPool中，看下实现： 
    final void work(ForkJoinWorkerThread w) {
        boolean swept = false;                // true on empty scans
        long c;
        while (!w.terminate && (int)(c = ctl) >= 0) {
            int a;                            // active count
            if (!swept && (a = (int)(c >> AC_SHIFT)) <= 0)
                swept = scan(w, a);
            else if (tryAwaitWork(w, c))
                swept = false;
        }
    }
       work方法中，while条件就是当前工作线程未结束且pool未关闭。while循环中，会不断的扫描(scan)或等待(tryAwaitWork)。如果扫描标志(起始为false)表示上一次扫描不是空扫描(false)，并且当前活动线程数量小于处理器核数(这里要注意下，返回去在看下控制信息中AC的定义)，那么进行扫描动作；否则进行等待(也就是说，当前没有任务需要执行的任务 或者 当前活动的线程数量已经大于处理器核心数)。
 
       而按照我们的流程，这里一定会先扫描到我们提交的任务，先看下scan方法： 
    private boolean scan(ForkJoinWorkerThread w, int a) {
        int g = scanGuard; 
        /*
         * 如果当前只有一个工作线程，将m设置为0，避免没用的扫描。
         * 否则获取guard值。
         */
        int m = (parallelism == 1 - a && blockedCount == 0) ? 0 : g & SMASK;
        ForkJoinWorkerThread[] ws = workers;
        if (ws == null || ws.length <= m)         // 过期检测
            return false;
        
        for (int r = w.seed, k = r, j = -(m + m); j <= m + m; ++j) {
            ForkJoinTask t; ForkJoinTask[] q; int b, i;
            //随机选出一个牺牲者(工作线程)。
            ForkJoinWorkerThread v = ws[k & m];
            //一系列检查...
            if (v != null && (b = v.queueBase) != v.queueTop &&
                (q = v.queue) != null && (i = (q.length - 1) & b) >= 0) {
                //如果这个牺牲者的任务队列中还有任务，尝试窃取这个任务。
                long u = (i << ASHIFT) + ABASE;
                if ((t = q[i]) != null && v.queueBase == b &&
                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
                    //窃取成功后，调整queueBase
                    int d = (v.queueBase = b + 1) - v.queueTop;
                    //将牺牲者的stealHint设置为当前工作线程在pool中的下标。
                    v.stealHint = w.poolIndex;
                    if (d != 0)
                        signalWork();             // 如果牺牲者的任务队列还有任务，继续唤醒(或创建)线程。
                    w.execTask(t); //执行窃取的任务。
                }
                //计算出下一个随机种子。
                r ^= r << 13; r ^= r >>> 17; w.seed = r ^ (r << 5);
                return false;                     // 返回false，表示不是一个空扫描。
            }
            //前2*m次，随机扫描。
            else if (j < 0) {                     // xorshift
                r ^= r << 13; r ^= r >>> 17; k = r ^= r << 5;
            }
            //后2*m次，顺序扫描。
            else
                ++k;
        }
        if (scanGuard != g)                       // staleness check
            return false;
        else {                                   
            //如果扫描完毕后没找到可窃取的任务，那么从Pool的提交任务队列中取一个任务来执行。
            ForkJoinTask t; ForkJoinTask[] q; int b, i;
            if ((b = queueBase) != queueTop &&
                (q = submissionQueue) != null &&
                (i = (q.length - 1) & b) >= 0) {
                long u = (i << ASHIFT) + ABASE;
                if ((t = q[i]) != null && queueBase == b &&
                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
                    queueBase = b + 1;
                    w.execTask(t);
                }
                return false;
            }
            return true;                         // 如果所有的队列(工作线程的任务队列和pool的任务队列)都是空的，返回true。
        }
    }
        细节：
              首先，需要确定扫描边界值m，如果当前只有一个工作线程，那么m就为0，避免多余的扫描；如果当前有多个工作线程，那么m就是scanGuard的低16位表示的值(去前面看看scanGuard)。
              其次，确定了m以后，开始一个for循环进行扫描。扫描的目的就是要通过工作线程的seed(这个域之前没提，使用来选择一个窃取牺牲者的)算出一个牺牲者(victim)的下标，牺牲者也是一个工作线程，然后当前工作线程便会从牺牲者的任务队列里面窃取一个任务来执行。当然如果算出的下标对应的位置上没有牺牲者(工作线程)，或者牺牲者的任务队列里没有任务，就会进行下一次尝试。整个for循环最多会尝试4*m次，前2*m次是随机算下标，每次会通过xorshift算法来生成新的k。后2*m次是顺序递增k来算下标。
              最后，如果for循环结束了还没有扫描到任务，那么就会从Pool的submissionQueue中窃取一个任务来执行了。
              
       由于是初始提交，scan方法中一定是从Pool的submissionQueue中获取我们提交的任务，然后执行。继续看执行任务调用的ForkJoinWorkerThread的execTask方法： 
    final void execTask(ForkJoinTask t) {
        currentSteal = t;
        for (;;) {
            if (t != null)
                //执行任务
                t.doExec();
            if (queueTop == queueBase)
                break; //如果当前工作线程的任务队列里没有任务了，退出循环。
            //否则，根据模式来获取任务。
            //如果Pool中指定为异步模式，这里从当前任务队列的尾部获取任务；否则，从任务队列头部获取任务。
            t = locallyFifo ? locallyDeqTask() : popTask();
        }
        ++stealCount; //最后累加窃取任务计数。
        currentSteal = null;
    }
       看下execTask方法中调用的的ForJoinTask的doExec方法： 
    final void doExec() {
        if (status >= 0) {
            boolean completed;
            try {
                //调用exec方法执行任务
                completed = exec();
            } catch (Throwable rex) {
                //设置异常完成结果
                setExceptionalCompletion(rex);
                return;
            }
            if (completed)
                setCompletion(NORMAL); // 设置正常完成结果
        }
    }
       ForJoinTask中的exec方法是一个抽象方法，具体执行逻辑交给子类去实现，我们前面看到的适配类AdaptedRunnable和AdaptedCallable里面，会在exec里面分别调用runnable.run()和callable.call()方法；而在ForJoinTask的两个子类RecursiveAction和RecursiveTask里面，exec里面调用的是compute方法： 
public abstract class RecursiveAction extends ForkJoinTask {
    private static final long serialVersionUID = 5232453952276485070L;
    /**
     * The main computation performed by this task.
     */
    protected abstract void compute();

    public final Void getRawResult() { return null; }

    protected final void setRawResult(Void mustBeNull) { }
    /**
     * Implements execution conventions for RecursiveActions.
     */
    protected final boolean exec() {
        compute();
        return true;
    }
}
public abstract class RecursiveTask extends ForkJoinTask {
    private static final long serialVersionUID = 5232453952276485270L;

    V result;
    /**
     * The main computation performed by this task.
     */
    protected abstract V compute();
    public final V getRawResult() {
        return result;
    }
    protected final void setRawResult(V value) {
        result = value;
    }
    /**
     * Implements execution conventions for RecursiveTask.
     */
    protected final boolean exec() {
        result = compute();
        return true;
    }
}
       注意ForJoinTask的exec方法有返回值，表示任务是否执行完毕。doExec方法中会根据这个返回值来设置任务的完成状态，如果任务正常完成，会调用setCompletion(NORMAL)： 
    /** The run status of this task */
    volatile int status; // accessed directly by pool and workers
    private static final int NORMAL      = -1;
    ...
    private int setCompletion(int completion) {
        for (int s;;) {
            if ((s = status) < 0)
                return s;
            //尝试将任务状态设置为正常完成。
            if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
                if (s != 0)
                    //同时唤醒合并当前任务的等待线程。
                    synchronized (this) { notifyAll(); }
                return completion;
            }
        }
    }
       doExec方法中如果执行exec方法发生异常，会调用setExceptionalCompletion方法来设置异常完成状态： 
    private int setExceptionalCompletion(Throwable ex) {
        //计算当前对象的原生hashCode。
        int h = System.identityHashCode(this);
        final ReentrantLock lock = exceptionTableLock;
        lock.lock();
        try {
            //删除异常表中过期的异常。
            expungeStaleExceptions();
            //获取异常表
            ExceptionNode[] t = exceptionTable;
            //通过当前对象hashCode获取在异常表中的下标。
            int i = h & (t.length - 1);
            //设置异常节点。
            for (ExceptionNode e = t[i]; ; e = e.next) {
                if (e == null) {
                    t[i] = new ExceptionNode(this, ex, t[i]);
                    break;
                }
                if (e.get() == this) // already present
                    break;
            }
        } finally {
            lock.unlock();
        }
        return setCompletion(EXCEPTIONAL);
    }
        细节：
       注意到setExceptionalCompletion方法中最后还是调用了setCompletion，但之前会做一下将异常放入一个异常表的工作。
       看到这里可能会有疑问，我们通过2个问题来了解下这个异常表：1.这里为什么会有一个异常表呢？2.异常表的结构是怎么样的呢？
       首先回答第1个问题：首先，因为异常很少发生，所以没有将异常保存在任务对象内，而是放在一个弱引用异常表里(异常表里不会保存取消异常)。
       再回答第2个问题：这里的异常表结构上是一个哈希表，每个桶里是单链，弱引用Key。
       结构细节参见异常表相关的结构代码：  
    private static final ExceptionNode[] exceptionTable;
    private static final ReentrantLock exceptionTableLock;
    private static final ReferenceQueue exceptionTableRefQueue;
    private static final int EXCEPTION_MAP_CAPACITY = 32;
    static final class ExceptionNode extends WeakReference>{
        final Throwable ex;
        ExceptionNode next;
        final long thrower;  // use id not ref to avoid weak cycles
        ExceptionNode(ForkJoinTask task, Throwable ex, ExceptionNode next) {
            super(task, exceptionTableRefQueue);
            this.ex = ex;
            this.next = next;
            this.thrower = Thread.currentThread().getId();
        }
    }
    ...
    // Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long statusOffset;
    static {
        exceptionTableLock = new ReentrantLock();
        exceptionTableRefQueue = new ReferenceQueue();
        exceptionTable = new ExceptionNode[EXCEPTION_MAP_CAPACITY];
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            statusOffset = UNSAFE.objectFieldOffset
                (ForkJoinTask.class.getDeclaredField("status"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }         
     
    
   
       继续我们的流程，执行完doExec，方法返回到execTask，接下来由于当前工作线程自身的任务队列中并没有任务，所以queueTop == queueBase成立，execTask方法退出到scan方法，scan方法返回false到ForkJoinPool的work方法，进行下一次扫描(scan)，由于工作线程本身的任务队列和Pool的任务队列都为空，所以下一次扫描一定是个空扫描，然后程序会走到work方法的tryAwaitWork分支，看下tryAwaitWork方法：
 
   
    private boolean tryAwaitWork(ForkJoinWorkerThread w, long c) {
        int v = w.eventCount;
        //w的nextWait保存的是等待之前Pool的控制信息。
        w.nextWait = (int)c;
        //这里是将当前线程的ID信息(下标取反)记录到Pool控制信息上
        //同时将控制信息上的活动工作线程计数减1。
        long nc = (long)(v & E_MASK) | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
        if (ctl != c || !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
            long d = ctl; 
            // 如果和另外的一个窃取线程竞争并失败，这里返回true，work方法中会继续扫描。
            return (int)d != (int)c && ((d - c) & AC_MASK) >= 0L;
        }
        for (int sc = w.stealCount; sc != 0;) {   
            //将工作线程上的stealCount原子累加到Pool的stealCount上面。
            long s = stealCount;
            if (UNSAFE.compareAndSwapLong(this, stealCountOffset, s, s + sc))
                sc = w.stealCount = 0;
            else if (w.eventCount != v)
                return true;                      //如果eventCount发生变化，重试。 
        }
        if ((!shutdown || !tryTerminate(false)) &&
            (int)c != 0 && parallelism + (int)(nc >> AC_SHIFT) == 0 &&
            blockedCount == 0 && quiescerCount == 0)
            //如果满足上面的条件，说明当前Pool休眠了，需要调用下idleAwaitWork进行处理。
            //上面的条件是：Pool未关闭 且 有工作线程 且 活动的工作线程数量等于cpu核心数量
            //且没有工作线程在合并过程中阻塞 且 没有工作线程休眠。 
            idleAwaitWork(w, nc, c, v);           // quiescent
        for (boolean rescanned = false;;) {
            if (w.eventCount != v)
                return true; //如果eventCount发生变化，重试。
            if (!rescanned) {
                int g = scanGuard, m = g & SMASK;
                ForkJoinWorkerThread[] ws = workers;
                if (ws != null && m < ws.length) {
                    rescanned = true;
                    //这里再重新扫描一下，如果从其他工作线程任务队列里找到任务，尝试唤醒等待的工作线程。
                    for (int i = 0; i <= m; ++i) {
                        ForkJoinWorkerThread u = ws[i];
                        if (u != null) {
                            if (u.queueBase != u.queueTop &&
                                !tryReleaseWaiter())
                                rescanned = false; // 发生竞争，再次扫描。
                            if (w.eventCount != v)
                                return true;
                        }
                    }
                }
                if (scanGuard != g ||              // scanGuard发生变化
                    (queueBase != queueTop && !tryReleaseWaiter())) //或者从Pool任务队列中找到任务
                    rescanned = false; //再次扫描
                if (!rescanned)
                    Thread.yield();                // 出让cpu，减少竞争。
                else
                    Thread.interrupted();          // park前清除中断标记。
            }
            else {
                w.parked = true;                   // 设置park标记
                if (w.eventCount != v) {           //再检测一下。
                    w.parked = false;
                    return true;
                }
                LockSupport.park(this);
                rescanned = w.parked = false;
            }
        }
    }
 
   

             
    细节： 
   
 
   
 
           这个方法的目的就是阻塞工作线程w，但过程中有一些细节。首先，方法中要调整Pool的控制信息ctl，将w的ID信息设置到ctl上并将ctl上保存的活动工作线程数量减1；其次，在阻塞前，还会将w的窃取任务数量累计到Pool的总窃取任务数量(stealCount)上；再次，如果当前Pool正好处理休眠状态，那么要调用idleAwaitWork处理一下(可能会结束工作线程)；最后，再真正阻塞前还要扫描一下工作线程任务队列和Pool任务队列，如果发现有任务，会尝试唤醒一个等待工作线程(可能是自己)，这个过程要结束时会清除一下当前线程的中断标记，然后进行阻塞(以Pool为Blocker，相当于进入Pool的等待队列)。 
   
 
   

       
   
 
   
 
    
     
     
  • 如果按照我们的流程，到这儿就结束了，工作线程已经执行了我们提交的任务，然后阻塞等待了。但如果当前Pool正好处于休眠状态了，看看会怎么样，继续看下上面方法中调用的idleAwaitWork方法：
    •  
    
 
    
    private void idleAwaitWork(ForkJoinWorkerThread w, long currentCtl,
                               long prevCtl, int v) {
        if (w.eventCount == v) {
            if (shutdown)
                tryTerminate(false); //如果关闭方法已经被调用，那么调用tryTerminate
            ForkJoinTask.helpExpungeStaleExceptions(); // 清理一下异常表中weak key
            while (ctl == currentCtl) {
                long startTime = System.nanoTime();
                w.parked = true;
                if (w.eventCount == v)             
                    LockSupport.parkNanos(this, SHRINK_RATE); //阻塞给定时间(4秒)
                w.parked = false;
                if (w.eventCount != v)
                    break;
                else if (System.nanoTime() - startTime <
                         SHRINK_RATE - (SHRINK_RATE / 10)) 
                    Thread.interrupted();          // 如果发生伪唤醒，清除中断标志。
                //恢复之前的ctl，如果ctl一直没发生变化，会成功。
                else if (UNSAFE.compareAndSwapLong(this, ctlOffset,
                                                   currentCtl, prevCtl)) {
                    //结束工作线程
                    w.terminate = true;            // 设置结束标志。
                    w.eventCount = ((int)currentCtl + EC_UNIT) & E_MASK; //设置w的eventCount。
                    break;
                }
            }
        }
    }
 
    
       可见，idleAwaitWork方法中开始会检测一下Pool是否正在关闭，是的话要调用tryTerminate；否则会先将工作线程w阻塞一段时间(4s)，如果超过了这个时间，Pool的控制信息还没发生变化(说明Pool还是休眠状态)，那么就需要将w结束掉，会设置w的结束标记为true，同时设置w的eventCount，然后退出到tryAwaitWork方法，tryAwaitWork方法中检测到w的eventCount发生变化，会退出到work方法，work方法中检测到w的结束标记为true，主循环回退出，工作线程w就要结束了，结束时会调用w的onTermination方法(上面提到过)：
 
    
    protected void onTermination(Throwable exception) {
        try {
            terminate = true;
            cancelTasks();
            pool.deregisterWorker(this, exception);
        } catch (Throwable ex) {        // Shouldn't ever happen
            if (exception == null)      // but if so, at least rethrown
                exception = ex;
        } finally {
            if (exception != null)
                UNSAFE.throwException(exception);
        }
    }
 
    

             ForkJoinWorkerThread的onTermination方法中主要做了两件事：取消任务和从Pool中注销自己。 
    
 
    
       先看下取消任务：
 
    
    final void cancelTasks() {
        ForkJoinTask cj = currentJoin; 
        if (cj != null && cj.status >= 0)
            cj.cancelIgnoringExceptions(); //取消正在合并的任务
        ForkJoinTask cs = currentSteal;
        if (cs != null && cs.status >= 0)
            cs.cancelIgnoringExceptions(); //取消窃取的任务
        while (queueBase != queueTop) {
            ForkJoinTask t = deqTask(); //取消工作线程任务队列中的所有任务。
            if (t != null)
                t.cancelIgnoringExceptions();
        }
    }
 
    
       看下这个取消方法cancelIgnoringExceptions：
 
    
    private static final int CANCELLED   = -2;
    ...
    final void cancelIgnoringExceptions() {
        try {
            cancel(false);
        } catch (Throwable ignore) {
        }
    }
    public boolean cancel(boolean mayInterruptIfRunning) {
        return setCompletion(CANCELLED) == CANCELLED;
    }
    private int setCompletion(int completion) {
        for (int s;;) {
            if ((s = status) < 0)
                return s;
            if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
                if (s != 0)
                    synchronized (this) { notifyAll(); }
                return completion;
            }
        }
    }
 
    
    
 
   
 
   
       再看下ForkJoinWorkerThread从Pool中注销自己的代码：
 
   
    final void deregisterWorker(ForkJoinWorkerThread w, Throwable ex) {
        int idx = w.poolIndex;
        int sc = w.stealCount;
        int steps = 0;
        // Remove from array, adjust worker counts and collect steal count.
        // We can intermix failed removes or adjusts with steal updates
        do {
            long s, c;
            int g;
            if (steps == 0 && ((g = scanGuard) & SG_UNIT) == 0 &&
                UNSAFE.compareAndSwapInt(this, scanGuardOffset,
                                         g, g |= SG_UNIT)) {
                ForkJoinWorkerThread[] ws = workers;
                if (ws != null && idx >= 0 &&
                    idx < ws.length && ws[idx] == w)
                    ws[idx] = null;    // verify
                nextWorkerIndex = idx;
                scanGuard = g + SG_UNIT;
                steps = 1;
            }
            if (steps == 1 &&
                UNSAFE.compareAndSwapLong(this, ctlOffset, c = ctl,
                                          (((c - AC_UNIT) & AC_MASK) |
                                           ((c - TC_UNIT) & TC_MASK) |
                                           (c & ~(AC_MASK|TC_MASK)))))
                steps = 2;
            if (sc != 0 &&
                UNSAFE.compareAndSwapLong(this, stealCountOffset,
                                          s = stealCount, s + sc))
                sc = 0;
        } while (steps != 2 || sc != 0);
        if (!tryTerminate(false)) {
            if (ex != null)   // possibly replace if died abnormally
                signalWork();
            else
                tryReleaseWaiter();
        }
    }
 
   

            deregisterWorker方法中首先在一个while无限循环中完成工作线程注销的工作，包括3个阶段，全部完成后再执行下一步。之所以这样做是由于每个阶段都可能发生竞争，需要重试。第1阶段，会在获取顺序锁(scanGuard高16位)的情况下将Pool中工作线程对应的数组位置置空，并调整nextWorkerIndex；第2阶段，将控制信息ctl中的活动工作线程数量和总工作线程数量减1；第3阶段，将要注销工作线程的窃取任务数量累加到Pool的总窃取任务数量上。 
   
 
   
       deregisterWorker在完成注销线程工作后，还有可能会唤醒其他等待线程，首先会调用一下tryTerminate(false)： 
 
   
    private boolean tryTerminate(boolean now) {
        long c;
        while (((c = ctl) & STOP_BIT) == 0) {
            if (!now) {
                if ((int)(c >> AC_SHIFT) != -parallelism)
                    return false;
                if (!shutdown || blockedCount != 0 || quiescerCount != 0 ||
                    queueBase != queueTop) {
                    if (ctl == c) // staleness check
                        return false;
                    continue;
                }
            }
            if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, c | STOP_BIT))
                startTerminating();
        }
        if ((short)(c >>> TC_SHIFT) == -parallelism) { // signal when 0 workers
            final ReentrantLock lock = this.submissionLock;
            lock.lock();
            try {
                termination.signalAll();
            } finally {
                lock.unlock();
            }
        }
        return true;
    }
 
   

            tryTerminate中，如果参数为false(表示不会马上关闭Pool)，那么实现中会查看是否有活动的工作线程，有的话返回false。然后检查Pool是否还在运行中(包括Pool有没有被关闭、有没有等待合并的工作线程、有没有空闲的工作线程、提交队列中是否有任务等)，如果还在运行中，返回false。 否则会尝试设置关闭标志到控制信息，然后调用startTerminating方法，如果参数为true的话也会直接进行这些操作。然后再检测下如果当前总的工作线程为0，就会唤醒在termination条件上等待的线程了。 
   
 
   
       再看下这个startTerminating方法： 
 
   
    private void startTerminating() {
        //取消Pool提交任务队列中的任务。
        cancelSubmissions();
        for (int pass = 0; pass < 3; ++pass) {
            ForkJoinWorkerThread[] ws = workers;
            if (ws != null) {
                for (ForkJoinWorkerThread w : ws) {
                    if (w != null) {
                        //结束工作线程。
                        w.terminate = true;
                        if (pass > 0) {
                            //取消工作线程中任务队列的任务。
                            w.cancelTasks();
                            if (pass > 1 && !w.isInterrupted()) {
                                try {
                                    //中断工作线程。
                                    w.interrupt();
                                } catch (SecurityException ignore) {
                                }
                            }
                        }
                    }
                }
                //结束等待的工作线程。
                terminateWaiters();
            }
        }
    }
 
   

            startTerminating中大体流程如下： 
   
 
   

                   
    1.取消Pool中submissionQueue中的任务。 
   
 
   
 
                  2.将所有的工作线程的结束状态设置为true。 
   
 
   
 
                  3.取消所有工作线程的任务队列中未完成的任务。 
   
 
   
 
                  4.中断所有工作线程。 
   
 
   
 
                  5.结束还在等待的工作线程。 
   
 
   
       startTerminating中第1步会调用cancelSubmissions方法：
 
   
    private void cancelSubmissions() {
        while (queueBase != queueTop) {
            ForkJoinTask task = pollSubmission();
            if (task != null) {
                try {
                    task.cancel(false);
                } catch (Throwable ignore) {
                }
            }
        }
    }
    protected ForkJoinTask pollSubmission() {
        ForkJoinTask t; ForkJoinTask[] q; int b, i;
        while ((b = queueBase) != queueTop &&
               (q = submissionQueue) != null &&
               (i = (q.length - 1) & b) >= 0) {
            long u = (i << ASHIFT) + ABASE;
            if ((t = q[i]) != null &&
                queueBase == b &&
                UNSAFE.compareAndSwapObject(q, u, t, null)) {
                queueBase = b + 1;
                return t;
            }
        }
        return null;
    }
 
   
       startTerminating中第5步会调用terminateWaiters方法：
 
   
    private void terminateWaiters() {
        ForkJoinWorkerThread[] ws = workers;
        if (ws != null) {
            ForkJoinWorkerThread w; long c; int i, e;
            int n = ws.length;
            while ((i = ~(e = (int)(c = ctl)) & SMASK) < n &&
                   (w = ws[i]) != null && w.eventCount == (e & E_MASK)) {
                if (UNSAFE.compareAndSwapLong(this, ctlOffset, c,
                                              (long)(w.nextWait & E_MASK) |
                                              ((c + AC_UNIT) & AC_MASK) |
                                              (c & (TC_MASK|STOP_BIT)))) {
                    w.terminate = true;
                    w.eventCount = e + EC_UNIT;
                    if (w.parked)
                        UNSAFE.unpark(w);
                }
            }
        }
    }
 
   
 
    

              
     细节： 
    
 
    
 
            这个方法要注意一下，看到这里可能忽略一个细节，就是隐式的等待工作线程组成的链(也叫Treiber stack)。这里可能猛地一看，方法内部只唤醒了一个等待线程，这个等待线程的ID信息存储在Pool的控制信息中。但仔细看会发现，在设置(调整)ctl的时候，有这句w.nextWait & E_MASK，也就是说，唤醒了w之后，ctl里又会有另一个等待工作线程的ID信息(这个信息之前是存在w的nextWait上面的)。 
    
 
   
 
   

       
   
 
   
       好吧，回到deregisterWorker方法，假设当前Pool还在运行，那么tryTerminate(false)返回false，就会执行接下来的语句：
 
   
        if (!tryTerminate(false)) {
            if (ex != null)   // possibly replace if died abnormally
                signalWork();
            else
                tryReleaseWaiter();
        }
 
   
       如果有异常发生，会调用signalWork方法来唤醒或者创建一个工作线程；否则调用tryReleaseWaiter方法来尝试唤醒一个等待工作线程：
 
   
    private boolean tryReleaseWaiter() {
        long c; int e, i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
        if ((e = (int)(c = ctl)) > 0 && //如果有等待线程
            (int)(c >> AC_SHIFT) < 0 && //且当前活动线程数小于CPU核数
            (ws = workers) != null && //检测工作线程数组合法性
            (i = ~e & SMASK) < ws.length && //检测控制信息中等待的工作线程的ID信息的合法性。
            (w = ws[i]) != null) { //检测工作线程的合法性。
            long nc = ((long)(w.nextWait & E_MASK) |
                       ((c + AC_UNIT) & (AC_MASK|TC_MASK))); //尝试调整控制信息，增加活动工作线程计数，将Treiber stack下一个等待线程的ID信息设置到ctl
            if (w.eventCount != e ||
                !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc))
                return false; //如果发生冲突。
            w.eventCount = (e + EC_UNIT) & E_MASK; //累加w的eventCount
            if (w.parked)
                UNSAFE.unpark(w); //唤醒w。
        }
        return true;
    }
 
   
  
 
   
 
 
   
 
 
   
     
    
  • OK，让我们在回到ForkJoinWorkerThread的execTask方法(不要晕)：
    •  
   
 
   
    final void execTask(ForkJoinTask t) {
        currentSteal = t;
        for (;;) {
            if (t != null)
                t.doExec();
            if (queueTop == queueBase)
                break;
            t = locallyFifo ? locallyDeqTask() : popTask();
        }
        ++stealCount;
        currentSteal = null;
    }
 
   

            假如执行完t，发现当前工作的任务队列中还有任务，那么接下来就会根据当前Pool的工作模式(是否是同步模式)，来通过locallyDeqTask或者popTask获取一个任务出来继续执行。 
   
 
   

             
    细节： 
   
 
   
 
           工作线程中的任务队列(Pool中的任务队列也一样)，形式上是一个数组，但概念上是一个双端队列。但和其他双端队列(JDK里另外的双端队列实现)不一样的是，这里的队列只定义了三种操作：从队列首部入队(push)、从队列首部出队(pop)、从队列尾部出队(deg)。这里既然说是队列，但又说什么push、pop可能会让人感觉晕晕的，其实可以这样理解，双端队列就可以看成是栈和队列的混血。结合使用Pool内部工作原理来说，如果不是异步模式(默认)，那么就会把任务队列当成一个FIFO队列来使用；否则就相当于把任务队列当成一个栈来使用。 
   
 
   

       
   
 
   
       如果Pool不是异步模式(locallyFifo为false)，那么会执行popTask方法：
 
   
    private ForkJoinTask popTask() {
        int m;
        ForkJoinTask[] q = queue;
        if (q != null && (m = q.length - 1) >= 0) {
            for (int s; (s = queueTop) != queueBase;) {
                int i = m & --s;
                long u = (i << ASHIFT) + ABASE; // raw offset
                ForkJoinTask t = q[i];
                if (t == null)   // lost to stealer
                    break;
                if (UNSAFE.compareAndSwapObject(q, u, t, null)) {
                    queueTop = s; // or putOrderedInt
                    return t;
                }
            }
        }
        return null;
    }
 
   

            很明确，就是从当前任务队列pop一个任务出来。 
   
 
   

       
   
 
   
       如果Pool是异步模式(locallyFifo为true)，那么会执行locallyDeqTask方法：
 
   
    final ForkJoinTask locallyDeqTask() {
        ForkJoinTask t; int m, b, i;
        ForkJoinTask[] q = queue;
        if (q != null && (m = q.length - 1) >= 0) {
            while (queueTop != (b = queueBase)) {
                if ((t = q[i = m & b]) != null &&
                    queueBase == b &&
                    UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE,
                                                t, null)) {
                    queueBase = b + 1;
                    return t;
                }
            }
        }
        return null;
    }
 
   

            也很简单，就是从当前任务队列deg一个任务出来。 
   
 
   

       
   
 
   
 
    
     
     
  • 简单总结一下ForkJoinPool中的工作线程的工作流程：
    •  
    
 
    

            
         1.被创建，注册到Pool中，启动。 
    
 
    
 
               2.扫描所有工作线程的队列和Pool中的任务队列，窃取一个任务来执行。 
    
 
    
 
               3.执行完毕后，在从自身工作队列中获取任务来执行。 
    
 
    
 
               4.没任务执行了，会阻塞等待，如果正好赶上了Pool休眠，那么会被结束掉，从Pool中注销。 
    
 
    

        
    
 
    

        
    
 
    

        
    
 
    
 
     
 
      最后： 
     
 
    
 
   
 
   
       本篇虽然是通过一个非ForkJoin任务的执行过程来分析代码，但已经包含ForkJoinPool运行过程的大部分流程。下篇会再次通过一个ForkJoin任务的流程来重点分析下Fork/Join过程中涉及到的源码。   
 
   
 
 
   
 
 
   
 
 
   
 
 
   
 
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java并发,并发,JUC,Java,源码)

        

            

                
    
                    
  • ChatGPT for Bot在QQ、微信等平台实现直接和deepseek对话的AI聊天程序包！支持DeepSeek、Claude、Ollama等主流模型，提供人物调整，虚拟朋友、语音对话
                        struggle2025
人工智能chatgpt机器人
                        
    一、软件介绍文末提供安装包和源码下载ChatGPTforBot一款支持在QQ、微信等聊天平台直接跟DeepSeek语言模型聊天的程序！真正的AI聊天！支持DeepSeek、Claude、OpenAI、Gemini、ChatGLM、Ollama，人设调教，虚拟朋友、语音对话。它可以让你在聊天平台上对接语言模型，实现和语言模型的直接对话。个人使用总结，连入deepseek后，告诉它专业的知识，然后给人
    
                    
    • 
                    
  • springboot学生宿舍信息的系统（11574）
                        codercode2022
springboot后端java开发语言springgulp前端框架
                        
    有需要的同学，源代码和配套文档领取，加文章最下方的名片哦一、项目演示项目演示视频二、资料介绍完整源代码（前后端源代码+SQL脚本）配套文档（LW+PPT+开题报告）远程调试控屏包运行三、技术介绍Java语言SSM框架SpringBoot框架Vue框架JSP页面Mysql数据库IDEA/Eclipse开发四、项目截图有需要的同学，源代码和配套文档领取，加文章最下方的名片哦!
    
                    
    • 
                    
  • Java中的分布式（概念说明）
                        阿乾之铭
java分布式
                        
    1.分布式的基本概念1.1什么是分布式系统？分布式系统（DistributedSystem）：由多台服务器（或节点）协同工作，对外提供一个整体服务。不同节点之间通过网络通信来协同处理请求或共享数据，相对于「单体应用」而言，可以带来更高的吞吐量、可用性和灵活扩展能力。1.2分布式vs.单体架构单体架构所有业务模块部署在同一应用实例中，垂直扩容（升级服务器硬件）成为主要的扩展方式。优点：开发调试较简单
    
                    
    • 
                    
  • JAVA基础知识总结（2025速通）三
                        剑走偏锋o.O
java开发语言
                        
    文章目录前言final关键字1、修饰属性或者局部变量【掌握】2、方法【掌握】3、类【掌握】4、应用场景【理解】1、常量2、修饰属性3、修饰局部变量4、修饰方法5、修饰类Object类详解1、常用方法【掌握】2、了解的方法【了解】3、学习反射之后要掌握的方法【了解】4、学习线程之后要掌握的方法【了解】字符串处理类1、java.lang.String类的使用【掌握】2、正则表达式【了解】3、Strin
    
                    
    • 
                    
  • 完整VB串口程序源码，如何用VB编写串口程序，免费完整源代码下载
                        luckyext
开发语言物联网单片机stm32信息与通信
                        
    免费完整VB串口程序源码下载链接https://download.csdn.net/download/luckyext/90393287串口通信（SerialCommunication）是一种设备间进行数据传输的通信方式，在VB6（VisualBasic6.0）中，因为VB集成了串口控件，只需将控件导入，然后简单的设置一下就可以实现串口的收发。VB6中串口通信通常使用MicrosoftCommun
    
                    
    • 
                    
  • java笔记——Map循环指南
                        啊健的影子
java笔记python
                        
    一、遍历Map的三种方法Java中的Map是一种以键值对形式存储数据的容器，常用的实现类有HashMap、LinkedHashMap和TreeMap。遍历Map是我们在使用Map时最常遇到的问题之一，下面介绍三种常用的遍历方法。1.通过entrySet遍历Mapmap=newHashMap();map.put(1,"one");map.put(2,"two");map.put(3,"three")
    
                    
    • 
                    
  • Java进阶篇之Lambda表达式
                        code2cat
JavaJava进阶开发语言javaideintellij-ideaideamyeclipse
                        
    引言在前面的文章中，我们介绍了线程池（Java进阶篇之线程池）。你是不是经常遇到需要写大量匿名内部类的情况？比如，我们在使用Java的集合、事件监听器、或者某些框架时，常常需要实现接口中的单一方法。传统的方式往往会导致代码冗长，影响可读性。而Lambda表达式的出现，正是为了简化这些重复的代码，让我们能够以更加简洁、优雅的方式表达操作。今天，我们将深入探讨Java中的Lambda表达式，看看它如何
    
                    
    • 
                    
  • JS(70-89)
                        小箌
javascript开发语言学习
                        
    01_内置对象-Math介绍：Math对象是JavaScript提供的一个“数学”对象作用：提供了一系列做数学运算的方法Math对象包含的方法有：random：生成0-1之间的随机数（包含0不包括1）ceil：向上取整floor：向下取整max：找最大数min：找最小数pow：幂运算abs：绝对值生成任意范围随机数介绍：Math.random()随机数函数，返回一个0-1之间，并且包括0不包括1的
    
                    
    • 
                    
  • JS(1-69)
                        小箌
javascript开发语言学习
                        
    01_JS介绍1.1JS是什么1.JavaScript（是什么？)是一种运行在客户端（浏览器）的编程语言，实现人机交互效果。2.作用（做什么？)网页特效（监听用户的一些行为让网页作出对应的反馈)表单验证（针对表单数据的合法性进行判断）数据交互（获取后台的数据，渲染到前端服务端编程（node.js)3.JavaScript的组成（有什么？)ECMAScript:规定了js基础语法核心知识。口比如：变
    
                    
    • 
                    
  • ffmpeg源码分析：avformat_open_input()
                        风雨兼程8023
ffmpegffmpeg
                        
    目录一、avformat_alloc_context()二、init_input()2.1av_probe_input_format2()2.2av_probe_input_buffer2()2.3io_open三、read_header()本文简单分析FFmpeg中一个常用的函数：avformat_open_input()。该函数用于打开多媒体数据并且获得一些相关的信息。它的声明位于libavf
    
                    
    • 
                    
  • FFMpeg 源码分析 （3）avformat_open_input（）
                        雷霆小屁熊
FFmpegffmpeg
                        
    这个函数主要用来打开媒体资源。完成媒体格式的探测和获取相关的媒体信息的工作。函数完成定义如下：intavformat_open_input(AVFormatContext**ps,constchar*filename,AVInputFormat*fmt,AVDictionary**options){AVFormatContext*s=*ps;inti,ret=0;AVDictionary*tmp=
    
                    
    • 
                    
  • Java中List、Set、Map 之间的区别是什么？
                        伟主教
java基础篇javalistwindows
                        
    在Java中，List、Set和Map是三种常见的集合接口，它们有不同的特性和使用场景。以下是它们之间的主要区别：1.List定义：List是一种有序的集合，允许包含重复的元素。实现类：常见实现类有ArrayList、LinkedList、Vector等。特点：元素按插入顺序排列。可以通过索引访问元素。允许添加重复的元素。常用方法：add(Ee)：添加元素。get(intindex)：通过索引获取
    
                    
    • 
                    
  • BUUCTF 逆向工程(reverse)之Java逆向解密
                        若丶时光破灭
CTF-逆向工程CTF逆向工程
                        
    程序员小张不小心弄丢了加密文件用的秘钥，已知还好小张曾经编写了一个秘钥验证算法，聪明的你能帮小张找到秘钥吗？注意：得到的flag请包上flag{}提交下载好题目后，发现它是个以.class为后缀的。所以用JD-GUI打开这个文件。就可以看到Java代码importjava.util.ArrayList;importjava.util.Scanner;publicclassReverse{publi
    
                    
    • 
                    
  • FFMPEG源码分析：avformat_open_input()（媒体打开函数）
                        sunshineywz
ffmpeg
                        
    本文分析了FFMPEG中的媒体打开函数avformat_open_input()//参数ps包含一切媒体相关的上下文结构，有它就有了一切，本函数如果打开媒体成功，//会返回一个AVFormatContext的实例．//参数filename是媒体文件名或URL．//参数fmt是要打开的媒体格式的操作结构，因为是读，所以是inputFormat．此处可以//传入一个调用者定义的inputFormat，
    
                    
    • 
                    
  • ssm毕业设计基于SSM框架的中医养生系统设计与实现[文档+开题+PPT
                        IT实战课堂
课程设计
                        
    选题推荐——以防找不到我们，点击上方订阅专栏✌✌\Java毕设实战项目Python毕设项目源代码asp.net毕业设计项目Uniapp安卓毕业设计项目node.js毕业设计项目python毕业设计微信小程序毕业设计项目php毕业设计文末获取源码联系一、项目介绍1.1研究背景现在大家正处于互联网加的时代，这个时代它就是一个信息内容无比丰富，信息处理与管理变得越加高效的网络化的时代，这个时代让大家的生
    
                    
    • 
                    
  • ffmpeg源码简析（五）编码——avformat_alloc_output_context2()，avcodec_encode_video2()
                        小码哥_WS
流媒体-直播-编解码ffmpegffmpeg编码源码
                        
    1.avformat_alloc_output_context2()在基于FFmpeg的视音频编码器程序中，该函数通常是第一个调用的函数（除了组件注册函数av_register_all()）。avformat_alloc_output_context2()函数可以初始化一个用于输出的AVFormatContext结构体。它的声明位于libavformat\avformat.h，如下所示。intav
    
                    
    • 
                    
  • JAVA：序列化和反序列化为什么要实现Serializable接口
                        奋斗的狍子007
JAVAjava开发语言序列化Serializable
                        
    一、前言序列化和反序列化是什么1.序列化  序列化是将Java对象转换为字节流的过程。这个字节流包含了对象的类型和状态信息，可以在稍后通过反序列化过程重新构造出原始对象。序列化的核心作用就是对象状态的保存。  在Java中，要实现序列化，类必须实现java.io.Serializable接口。这个接口是一个标记接口，不包含任何方法，但它告诉Java虚拟机（JVM）这个类的对象可以被序列化。序列化场
    
                    
    • 
                    
  • FFmpeg源码：av_strlcpy函数分析
                        崔杰城
FFmpeg源码分析ffmpeg
                        
    一、引言在C/C++编程中经常会用到strcpy这个字符串复制函数。strcpy是C/C++中的一个标准函数，可以把含有'\0'结束符的字符串复制到另一个地址空间。但是strcpy不会检查目标数组dst的大小是否足以容纳源字符串src，如果目标数组太小，将会导致缓冲区溢出。针对该问题很多C/C++开源库都会选择自己实现strcpy函数来保证安全性。而FFmpeg自定义了av_strlcpy函数，在
    
                    
    • 
                    
  • Python动态特性详解
                        鸭梨山大哎
pythonjavapython开发语言
                        
    Java和Python在语言设计上有很大不同，尤其是在动态特性方面。Java是一种静态类型语言，强调编译时的类型检查和严格的类型约束，而Python是一种动态类型语言，强调运行时的灵活性和简洁性。下面通过对比Java和Python来讲解Python的动态特性。1.动态类型vs静态类型Python（动态类型）变量的类型在运行时确定，并且可以随时改变。示例：x=10#x是整数x="hello"#x变为
    
                    
    • 
                    
  • Java中的集合框架：List、Set和Map有什么区别？
                        大G哥
javalist开发语言数据结构
                        
    在Java的集合框架中，List、Set和Map是三种常见的集合接口，它们各自有不同的特性和用途。以下是它们之间的主要区别和特点：1.List定义：List是一个有序的集合，允许存储重复的元素，并且可以通过索引访问元素。特点：元素是有序的(按照插入顺序排列)。允许存储重复的元素。可以通过索引(下标)访问元素，支持随机访问。常用实现类包括ArrayList、LinkedList和Vector。适用场
    
                    
    • 
                    
  • 解剖DeepSeek四把刀，一场深到源码，大到行业，细到人心盛宴
                        leluckys
AI大模型AI编程
                        
    在拆解DeepSeek源码后，会发现几个颠覆行业认知的真相。这个号称“用十分之一算力吊打GPT-4”的国产大模型，藏着令人拍案叫绝的工程智慧，却也暗藏致命软肋。第一刀：切开开源表象，DeepSeek确实把代码仓库甩上了GitHub,但这套开源策略藏着精妙算计。他们公开的是经过蒸馏的“成品模型”，而非原始训练框架：就像给你组装好的乐高战舰，却藏起了设计图纸。这种半开放式开源既能吸引开发者构建生态，又
    
                    
    • 
                    
  • Python线程安全队列的使用与优化：单队列与多队列处理的对比
                        kdayjj966
python开发语言
                        
    在多线程编程中，队列（Queue）是一个非常重要的工具，尤其是在需要线程安全时。本文通过一个实际案例，讲解如何在Python中高效使用队列，并介绍优化代码以提升灵活性和可扩展性的方法。问题背景在多线程环境中，我们常常需要共享数据，并对其进行并发操作。例如，一个线程对数据进行加1操作，另一个线程对数据进行减1操作，最终希望数据能正确处理并输出。以下是一个使用单队列的简单案例：代码如下：importt
    
                    
    • 
                    
  • 工具箱之父小程序源码（二）--萌宠大作战部分
                        jackzhuoa
微信小程序从零到万微信小程序游戏王者荣耀
                        
    微信小程序搜一搜工具箱之父.game-container{position:relative;width:100vw;height:100vh;background-color:#000;}.game-canvas{width:100%;height:100%;}/*游戏信息样式*/.game-info{position:absolute;top:40rpx;left:40rpx;right:40
    
                    
    • 
                    
  • Trae 项目常见问题解决方案
                        强和毓Hadley

                        
    Trae项目常见问题解决方案trae:postbox:MinimalisticFetchbasedHTTPclient项目地址:https://gitcode.com/gh_mirrors/tr/trae项目基础介绍Trae是一个基于FetchAPI的极简HTTP客户端，旨在提供一个简单、轻量级的HTTP请求工具。该项目的主要编程语言是TypeScript和JavaScript。Trae的设计理念
    
                    
    • 
                    
  • Janino 不思进取了？Java 动态编译 的新神器 Liquor v1.3.10 发布
                        组合缺一
SolonJavaFrameworkjava开发语言solonliquor动态编译器
                        
    Liquor是一个开源的轻量级Java动态编译器（零依赖，40KB），基于javac构建，可在运行时编译Java（支持java8到java23语法）字符串代码片段、类、方法等。源码地址：https://gitee.com/noear/liquor基础编译特性：可以单个类编译可以多个类同时编译可以增量编译增值特性：java表达式引擎java脚本引擎（支持java8到java23语法）本次更新添加Sc
    
                    
    • 
                    
  • 2025 年微信小程序毕业设计大全，400 道微信小程序毕业设计题目推荐
                        Java徐师兄
小程序毕业设计Java大学生实战项目微信小程序课程设计小程序毕业设计题目大全小程序毕业设计推荐
                        
    博主介绍：✌Java徐师兄、7年大厂程序员经历。全网粉丝13w+、csdn博客专家、掘金/华为云等平台优质作者、专注于Java技术领域和毕业项目实战✌文末获取源码联系精彩专栏推荐订阅不然下次找不到哟2022-2024年最全的计算机软件毕业设计选题大全：1000个热门选题推荐✅Java项目精品实战案例《100套》Java微信小程序项目实战《100套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以
    
                    
    • 
                    
  • Java面试宝典：说下Spring Bean的生命周期？
                        熊文豪
Java面试宝典java面试springSpringBeanBeanBean的生命周期
                        
    Java面试宝典专栏范围：JAVA基础，面向对象编程（OOP），异常处理，集合框架，JavaI/O，多线程编程，设计模式，网络编程，框架和工具等全方位面试题详解每日更新Java面试宝典专栏：Java面试宝典感兴趣的可以先收藏起来，大家在遇到JAVA面试题等相关问题都可以给我留言咨询，希望帮助更多的人回答重点实例化：Spring容器根据配置文件或注解实例化Bean对象。属性注入：Spring将依赖（
    
                    
    • 
                    
  • CentOS7 源码安装python3
                        Jerion929
centoslinuxpython
                        
    一、安装依赖包首先，确保系统中安装了编译Python所需的依赖包。可以通过以下命令安装：yumgroupinstall-y"DevelopmentTools"#CentOS8用此命令yuminstall-y\openssl-devel\bzip2-devel\libffi-devel\zlib-devel\readline-devel\sqlite-devel\wget\gcc"Developme
    
                    
    • 
                    
  • JAVA数组笔记
                        @未来可期
计算机java开发语言
                        
    数组1.定义：存放相同数据类型的集合2.创建数组的两种方式静态初始化：int[]arr={1,2,3,4,5};动态初始化：int[]arr=newint[]{1,2,3,4,5};需要注意的是，在经过编译后，编译器会自动将静态初始化转变为动态初始化。3，数组的访问和长度在JAVA中，取得数组的长度只需要数组名.length即可取得某个数组元素则需要arr[index]数组下标为0~length-
    
                    
    • 
                    
  • Java永久性修改Linux(Debian/Ubuntu)网络
                        久违放晴
linuxjavadebianubuntu网络
                        
    文章目录前言一、实现思路二、手动配置网络（一）编辑/etc/network/interfaces文件（二）重启网络（三）查看网络配置三、shell脚本配置网络（一）脚本执行流程（二）编写脚本（三）完整代码（四）脚本执行方式（五）直接覆盖版（六）使用工具包的实现方案四、通过Java调用shell脚本（一）SSH远程连接调用（二）使用本地指令调用的方案总结前言对于一些私有化部署的系统，部署完毕后经常需
    
                    
    • 
                                
  • 戴尔笔记本win8系统改装win7系统
                                    sophia天雪
win7戴尔改装系统win8
                                    
    戴尔win8 系统改装win7 系统详述  
 
第一步：使用U盘制作虚拟光驱： 
        1）下载安装UltraISO：注册码可以在网上搜索。 
        2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文 

    
                                
    • 
                                
  • BeanUtils.copyProperties使用笔记
                                    bylijinnan
java
                                    
    BeanUtils.copyProperties VS PropertyUtils.copyProperties 
 
两者最大的区别是： 
BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。 
既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
    
                                
    • 
                                
  • MyEclipse中文乱码问题
                                    0624chenhong
MyEclipse
                                    
    一、设置新建常见文件的默认编码格式，也就是文件保存的格式。 
在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。 
在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 
Window-->Preferences-->General -
    
                                
    • 
                                
  • 发送邮件
                                    不懂事的小屁孩
send email
                                    
      
import org.apache.commons.mail.EmailAttachment;  
import org.apache.commons.mail.EmailException;  
import org.apache.commons.mail.HtmlEmail;  
import org.apache.commons.mail.MultiPartEmail;  

    
                                
    • 
                                
  • 动画合集
                                    换个号韩国红果果
htmlcss
                                    
    动画 指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 
1 transition  制作鼠标滑过图片时的放大效果 
 

css
.wrap{
		width: 340px;height: 340px;
		position: absolute;
		top: 30%;
		left: 20%;
		overflow: hidden;
		bor
    
                                
    • 
                                
  • 网络最常见的攻击方式竟然是SQL注入
                                    蓝儿唯美
sql注入
                                    
    NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。 
信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击 行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
    
                                
    • 
                                
  • java笔记2
                                    a-john
java
                                    
    类的封装： 
1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 
2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 
3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 
4，封装的特性： 
      4.1设置
    
                                
    • 
                                
  • [Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx”
                                    aijuans
学习Android遇到的错误
                                    
            最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。 
 
昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。 
 
我就看了一下，和她要了psd的文件，还好我有一点
    
                                
    • 
                                
  • 自己写的一个繁体到简体的转换程序
                                    asialee
java转换繁体filter简体
                                    
              今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。 
         实现的思路是重载request的调取参数的几个方法，然后做下转换。 
          
    
                                
    • 
                                
  • android意图和意图监听器技术
                                    百合不是茶
android显示意图隐式意图意图监听器
                                    
    Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递 
  
显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。 
  
隐式意图;不指明调用的名称,根据设
    
                                
    • 
                                
  • spring3中新增的@value注解
                                    bijian1013
javaspring@Value
                                    
            在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 
1.首先在applicationContext.xml中加入：    
<beans xmlns="http://www.springframework.
    
                                
    • 
                                
  • Jboss启用CXF日志
                                    sunjing
logjbossCXF
                                    
    1. 在standalone.xml配置文件中添加system-properties： 
    <system-properties>        <property name="org.apache.cxf.logging.enabled" value=&
    
                                
    • 
                                
  • 【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码
                                    bit1129
centos
                                    
      编译必需的软件 
 
 Firebugs3.0.0 
 Maven3.2.3 
 Ant 
 JDK1.7.0_67 
 protobuf-2.5.0 
 Hadoop 2.5.2源码包 
 
  
  
  
 
 Firebugs3.0.0 
 
  
http://sourceforge.jp/projects/sfnet_findbug
    
                                
    • 
                                
  • struts2验证框架的使用和扩展
                                    白糖_
框架xmlbeanstruts正则表达式
                                    
    struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 
1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 
2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。 
本文介绍一下struts2通过xml文件进行校验的方法并说
    
                                
    • 
                                
  • 记录-感悟
                                    braveCS
感悟
                                    
    再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 
  
2015-1-11  1. 能在工作之余学习感兴趣的东西已经很幸福了； 
2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 
3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 
4. 一天内集中一个定长时间段看最新资讯和偏流式博
    
                                
    • 
                                
  • 编程之美-数组中最长递增子序列
                                    bylijinnan
编程之美
                                    
    
import java.util.Arrays;
import java.util.Random;

public class LongestAccendingSubSequence {

	/**
	 * 编程之美 数组中最长递增子序列 
	 * 书上的解法容易理解
	 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组，
	 * 然后求排序后的数组与原数
    
                                
    • 
                                
  • 读书笔记5
                                    chengxuyuancsdn
重复提交struts2的token验证
                                    
    1、重复提交 
2、struts2的token验证 
3、用response返回xml时的注意 
 
1、重复提交 
(1)应用场景 
(1-1)点击提交按钮两次。 
(1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 
(1-3)刷新页面 
(1-4)使用浏览器历史记录重复提交表单。 
(1-5)浏览器重复的 HTTP 请求。 
(2)解决方法 
(2-1)禁掉提交按钮 
(2-2)
    
                                
    • 
                                
  • [时空与探索]全球联合进行第二次费城实验的可能性
                                    comsci

                                    
     
 
     二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验 
  至今给我们大家留下很多迷团..... 
 
     关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了 
 
     在这里,我的意思是,现在
    
                                
    • 
                                
  • easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符
                                    daizj
oracleORA-12154
                                    
    用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： 
C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl 
SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 
Copyright (c) 198
    
                                
    • 
                                
  • 简单排序:归并排序
                                    dieslrae
归并排序
                                    
    
    public void mergeSort(int[] array){
        int temp = array.length/2;
        
        if(temp == 0){
            return;
        }
        
        int[] a = new int[temp];
        int
    
                                
    • 
                                
  • C语言中字符串的\0和空格
                                    dcj3sjt126com
c
                                    
       \0 为字符串结束符，比如说： 
                      abcd (空格)cdefg； 
存入数组时，空格作为一个字符占有一个字节的空间，我们
    
                                
    • 
                                
  • 解决Composer国内速度慢的办法
                                    dcj3sjt126com
Composer
                                    
    用法： 
有两种方式启用本镜像服务： 
1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 
2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 
为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下      1   2   3   4   5    
    
                                
    • 
                                
  • 高效可伸缩的结果缓存
                                    shuizhaosi888
高效可伸缩的结果缓存
                                    
    /**
 * 要执行的算法，返回结果v
 */
public interface Computable<A, V> {
	public V comput(final A arg);

}
 
  
/**
 * 用于缓存数据
 */
public class Memoizer<A, V> implements Computable<A, 
    
                                
    • 
                                
  • 三点定位的算法
                                    haoningabc
c算法
                                    
    三点定位， 
已知a,b,c三个顶点的x,y坐标 
和三个点都z坐标的距离，la，lb,lc 
 
求z点的坐标 
原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求 
但是，由于三个点的距离可能不准，不一定会有结果， 
所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 
运行 
gcc -lm test.c 
test.c代码如下 
 

#include "stdi
    
                                
    • 
                                
  • epoll使用详解
                                    jimmee
clinux服务端编程epoll
                                    
    epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
    
                                
    • 
                                
  • Hibernate对Enum的映射的基本使用方法
                                    linzx0212
enumHibernate
                                    
      
枚举 
  
/**
 * 性别枚举
 */
public enum Gender {

    MALE(0), FEMALE(1), OTHER(2);

    private Gender(int i) {
        this.i = i;
    }

    private int i;

    public int getI
    
                                
    • 
                                
  • 第10章 高级事件（下）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 孙子兵法
                                    roadrunners
孙子兵法
                                    
    始计第一 
 
孙子曰： 
兵者，国之大事，死生之地，存亡之道，不可不察也。 
故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五 
曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑 
、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法 
者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校 
之以计，而索其情，曰
    
                                
    • 
                                
  • MySQL双向复制
                                    tomcat_oracle
mysql
                                    
    本文包括: 
 
  主机配置  
  从机配置  
  建立主-从复制  
  建立双向复制  
 
  背景 
按照以下简单的步骤: 
参考一下： 
 
  在机器A配置主机(192.168.1.30)  
  在机器B配置从机(192.168.1.29)  
  我们可以使用下面的步骤来实现这一点  
 
  
步骤1：机器A设置主机 
 
  在主机中打开配置文件 , 
    
                                
    • 
                                
  • zoj 3822 Domination(dp)
                                    阿尔萨斯
Mina
                                    
     题目链接：zoj 3822 Domination 
 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。 
 解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理
    
                                
    •