1 /*

     2  * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.apple.concurrent;

    27 

    28 import java.util.List;

    29 import java.util.concurrent.*;

    30 

    31 class LibDispatchSerialQueue extends AbstractExecutorService {

    32         static final int RUNNING    = 0;

    33     static final int SHUTDOWN   = 1;

    34 //  static final int STOP       = 2; // not supported by GCD

    35     static final int TERMINATED = 3;

    36 

    37     final Object lock = new Object();

    38         LibDispatchQueue nativeQueueWrapper;

    39     volatile int runState;

    40 

    41         LibDispatchSerialQueue(final long queuePtr) {

    42                 nativeQueueWrapper = new LibDispatchQueue(queuePtr);

    43         }

    44 

    45         @Override

    46         public void execute(final Runnable task) {

    47                 if (nativeQueueWrapper == null) return;

    48                 LibDispatchNative.nativeExecuteAsync(nativeQueueWrapper.ptr, task);

    49         }

    50 

    51         @Override

    52         public boolean isShutdown() {

    53                 return runState != RUNNING;

    54         }

    55 

    56         @Override

    57         public boolean isTerminated() {

    58                 return runState == TERMINATED;

    59         }

    60 

    61         @Override

    62         public void shutdown() {

    63                 synchronized (lock) {

    64                         if (runState != RUNNING) return;

    65 

    66                         runState = SHUTDOWN;

    67                         execute(new Runnable() {

    68                                 public void run() {

    69                                         synchronized (lock) {

    70                                                 runState = TERMINATED;

    71                                                 lock.notifyAll(); // for the benefit of awaitTermination()

    72                                         }

    73                                 }

    74                         });

    75                         nativeQueueWrapper = null;

    76                 }

    77         }

    78 

    79         @Override

    80         public List<Runnable> shutdownNow() {

    81                 shutdown();

    82                 return null;

    83         }

    84 

    85         @Override

    86         public boolean awaitTermination(final long timeout, final TimeUnit unit) throws InterruptedException {

    87                 if (runState == TERMINATED) return true;

    88 

    89                 final long millis = unit.toMillis(timeout);

    90                 if (millis <= 0) return false;

    91 

    92                 synchronized (lock) {

    93                         if (runState == TERMINATED) return true;

    94                         lock.wait(timeout);

    95                         if (runState == TERMINATED) return true;

    96                 }

    97 

    98                 return false;

    99         }

   100 }