public void write(
      final long position,
      final long size,
      final ByteBuffer directByteBuffer,
      final AIOCallback aioCallback) {
    if (aioCallback == null) {
      throw new NullPointerException("Null Callback");
    }

    checkOpened();
    if (poller == null) {
      startPoller();
    }

    pendingWrites.countUp();

    if (writeExecutor != null) {
      maxIOSemaphore.acquireUninterruptibly();

      writeExecutor.execute(
          new Runnable() {
            public void run() {
              long sequence = nextWritingSequence.getAndIncrement();

              try {
                write(handler, sequence, position, size, directByteBuffer, aioCallback);
              } catch (HornetQException e) {
                callbackError(
                    aioCallback, sequence, directByteBuffer, e.getType().getCode(), e.getMessage());
              } catch (RuntimeException e) {
                callbackError(
                    aioCallback,
                    sequence,
                    directByteBuffer,
                    HornetQExceptionType.INTERNAL_ERROR.getCode(),
                    e.getMessage());
              }
            }
          });
    } else {
      maxIOSemaphore.acquireUninterruptibly();

      long sequence = nextWritingSequence.getAndIncrement();

      try {
        write(handler, sequence, position, size, directByteBuffer, aioCallback);
      } catch (HornetQException e) {
        callbackError(
            aioCallback, sequence, directByteBuffer, e.getType().getCode(), e.getMessage());
      } catch (RuntimeException e) {
        callbackError(
            aioCallback,
            sequence,
            directByteBuffer,
            HornetQExceptionType.INTERNAL_ERROR.getCode(),
            e.getMessage());
      }
    }
  }
예제 #2
0
  public void transicion(int tipoHilo, int transicion) {

    // Entra al monitor
    ingreso.acquireUninterruptibly();

    // El valor de "transicion" representa la transición a disparar
    // transicion = X significa que quiero disparar TX
    // HAY QUE TENER ORDENADAS LAS COLUMNAS DE LA MATRIZ DE INCIDENCIA DEL PIPE

    // Creamos un vector cuyo tamaño sea el número de transiciones, que es el número de columnas
    // de la matriz de incidencia
    int[] vectorT = new int[incidencia[0].length];

    for (int i = 0; i < incidencia[0].length; i++) {
      vectorT[i] = 0;
    }

    vectorT[transicion] = 1;

    // Para saber si la transición está habilitada, el monitor multiplica la matriz de incidencia
    // por el vector de disparo, y lo suma al vector de marcado actual. Si algún elemento del vector
    // resultante es menor a cero, no está habilitada esa transición. De lo contrario, el marcado
    // actual es reemplazado por el vector resultante.

    marcado = sensibilidad(incidencia, vectorT, tipoHilo);

    // Liberar Cola
    liberarCola();

    // Libero el monitor
    ingreso.release();

    return;
  }
예제 #3
0
  /** Run a job. */
  static void runJob(String name, Job job, Machine machine, String startmessage, Util.Timer timer) {
    JOB_SEMAPHORE.acquireUninterruptibly();
    Long starttime = null;
    try {
      try {
        starttime = timer.tick("starting " + name + " ...\n  " + startmessage);

        // initialize and submit a job
        machine.init(job);
        job.submit();

        // Separate jobs
        final long sleeptime = 1000L * job.getConfiguration().getInt(JOB_SEPARATION_PROPERTY, 10);
        if (sleeptime > 0) {
          Util.out.println(name + "> sleep(" + Util.millis2String(sleeptime) + ")");
          Thread.sleep(sleeptime);
        }
      } finally {
        JOB_SEMAPHORE.release();
      }

      if (!job.waitForCompletion(false)) throw new RuntimeException(name + " failed.");
    } catch (Exception e) {
      throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
    } finally {
      if (starttime != null)
        timer.tick(name + "> timetaken=" + Util.millis2String(timer.tick() - starttime));
    }
  }
  public RtspClient() {
    mCSeq = 0;
    mTmpParameters = new Parameters();
    mTmpParameters.port = 1935;
    mTmpParameters.path = "/";
    mTmpParameters.transport = TRANSPORT_UDP;
    mAuthorization = null;
    mCallback = null;
    mMainHandler = new Handler(Looper.getMainLooper());
    mState = STATE_STOPPED;

    final Semaphore signal = new Semaphore(0);
    new HandlerThread("RtspClient") {
      @Override
      protected void onLooperPrepared() {
        mHandler =
            new Handler() {

              @Override
              public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msg.what == RtpThread.WHAT_THREAD_END_UNEXCEPTION) {
                  if (mCallback != null) {
                    mCallback.onRtspUpdate(RtpThread.WHAT_THREAD_END_UNEXCEPTION, null);
                  } else {
                    stopStream();
                  }
                }
              }
            };
        signal.release();
      }
    }.start();
    signal.acquireUninterruptibly();
  }
예제 #5
0
  public int getQuotaToUse(int want) {
    waiterSemaphore.acquireUninterruptibly();

    try {
      // take element from the queue, add the remaining back to the queue
      Integer q = queue.take();

      if (q > want) {
        queue.put(new Integer(q - want));
        // had more than wanted
        return want;
      } else if (q <= want) {
        // had less than wanted
        return q;
      }
      ;
      // will not happen
      return 0;
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      return 0;
    } finally {
      waiterSemaphore.release();
    }
  }
 public void read(
     final long position,
     final long size,
     final ByteBuffer directByteBuffer,
     final AIOCallback aioPackage)
     throws HornetQException {
   checkOpened();
   if (poller == null) {
     startPoller();
   }
   pendingWrites.countUp();
   maxIOSemaphore.acquireUninterruptibly();
   try {
     read(handler, position, size, directByteBuffer, aioPackage);
   } catch (HornetQException e) {
     // Release only if an exception happened
     maxIOSemaphore.release();
     pendingWrites.countDown();
     throw e;
   } catch (RuntimeException e) {
     // Release only if an exception happened
     maxIOSemaphore.release();
     pendingWrites.countDown();
     throw e;
   }
 }
예제 #7
0
        public void run() {
          while (running) {
            try {
              ignore.acquireUninterruptibly();
              if (!running) break;
              ignore.release();

              if (srv == null) srv = new ServerSocket(port);

              if (connecting == null) {
                connecting = new ServerConnection();
              }
              if (connecting.connect(srv, password)) {
                add(connecting);
                owner.add(connecting, privilege);
                connecting = null;
              }
            } catch (IOException e) {
              if (running && !isIgnoring()) {
                owner.println("Port unavailable, please select a different port.");
                owner.println("Ignoring new connections.");
                ignore(true);
              }
            }
          }
        }
예제 #8
0
 public void start() {
     gatewayThread = new Thread(new GatewayRunner());
     feedbackThread = new Thread(new FeedbackRunner());
     gatewayThread.start();
     feedbackThread.start();
     startUp.acquireUninterruptibly(2);
 }
  public Map<String, Object> process(Map<String, Object> input) {
    if (!isValid) {
      validate(true);
    }
    Long currentProcessId = processId.incrementAndGet();
    Semaphore resultSemaphoreForProcess = new Semaphore(0);
    resultSemaphores.put(currentProcessId, resultSemaphoreForProcess);

    // send input to all input pipeline stages
    for (PipelineStage inputStage : inputStages.keySet()) {
      Map<String, String> inputPortMapping = inputStages.get(inputStage);
      for (String inputPort : inputPortMapping.keySet()) {
        Object inputParam = input.get(inputPort);
        inputStage.consume(currentProcessId, inputPortMapping.get(inputPort), inputParam);
      }
    }

    // wait for the output to become ready
    resultSemaphoreForProcess.acquireUninterruptibly();

    if (Boolean.FALSE == processingStatus.remove(currentProcessId)) {
      Throwable t = processingException.remove(currentProcessId);
      throw new PipelineProcessingException(
          "Processing failed for id '" + currentProcessId + "'.", t);
    }
    // cleanup and return the result
    return clear(currentProcessId);
  }
예제 #10
0
  @Test
  public void noExecutableFound() {
    System.err.println("Starting test noExecutableFound()");

    final Semaphore semaphore = new Semaphore(0);
    final AtomicInteger exitCode = new AtomicInteger();

    NuProcessHandler processListener =
        new NuAbstractProcessHandler() {
          @Override
          public void onExit(int statusCode) {
            exitCode.set(statusCode);
            semaphore.release();
          }
        };

    NuProcessBuilder pb = new NuProcessBuilder(processListener, "/bin/zxczxc");
    NuProcess process = pb.start();
    semaphore.acquireUninterruptibly();
    Assert.assertFalse("Process incorrectly reported running", process.isRunning());
    Assert.assertEquals(
        "Output did not matched expected result", Integer.MIN_VALUE, exitCode.get());

    System.err.println("Completed test noExecutableFound()");
  }
예제 #11
0
  public void place_order(Company company, int quantity, String buy_sell, byte user_system) {
    Contract contract = company.create_contract();
    Order order = company.create_order(buy_sell, quantity);

    sem_oid.acquireUninterruptibly();

    OpenOrder oo = new OpenOrder(order, company, user_system);
    open_order_map.put(next_orderId, oo);
    client.placeOrder(next_orderId, contract, order);

    String message =
        df_user.format(Calendar.getInstance().getTime())
            + buy_sell
            + " ORDER placed: "
            + company.name()
            + "x"
            + quantity;

    message = (user_system == 0) ? message + " BY USER" : message;

    next_orderId++;
    sem_oid.release();

    q.offer(message);
  }
예제 #12
0
 private void schedule() {
   queueSize.acquireUninterruptibly();
   for (Map.Entry<String, WeightedQueue> request : queues.entrySet()) {
     WeightedQueue queue = request.getValue();
     // Using the weight, process that many requests at a time (for that scheduler id)
     for (int i = 0; i < queue.weight; i++) {
       Thread t = queue.poll();
       if (t == null) break;
       else {
         taskCount.acquireUninterruptibly();
         queueSize.acquireUninterruptibly();
       }
     }
   }
   queueSize.release();
 }
예제 #13
0
 /**
  * Return stream state
  *
  * @return StreamState
  */
 public StreamState getState() {
   try {
     lock.acquireUninterruptibly();
     return state;
   } finally {
     lock.release();
   }
 }
  public static Handler getHandler() {
    if (_handler == null) {
      _ready.acquireUninterruptibly();
      _ready.release();
    }

    return _handler;
  }
예제 #15
0
 public void acquireRead() {
   assert (!readLocks.contains(Thread.currentThread()));
   if (!lock.tryAcquire()) {
     WorkerThread.beginIO();
     lock.acquireUninterruptibly();
     WorkerThread.endIO();
   }
   readLocks.add(Thread.currentThread());
 }
예제 #16
0
    void offer(Action action) {
      if (DEBUG) {
        assertOnIcThread();
        Log.d(
            LOGTAG, "offer: Action(" + getConstantName(Action.class, "TYPE_", action.mType) + ")");
      }
      /* Events don't need update because they generate text/selection
      notifications which will do the updating for us */
      if (action.mType != Action.TYPE_EVENT
          && action.mType != Action.TYPE_ACKNOWLEDGE_FOCUS
          && action.mType != Action.TYPE_SET_HANDLER) {
        action.mShouldUpdate = mUpdateGecko;
      }
      if (mActions.isEmpty()) {
        mActionsActive.acquireUninterruptibly();
        mActions.offer(action);
      } else
        synchronized (this) {
          // tryAcquire here in case Gecko thread has just released it
          mActionsActive.tryAcquire();
          mActions.offer(action);
        }

      switch (action.mType) {
        case Action.TYPE_EVENT:
        case Action.TYPE_SET_SELECTION:
        case Action.TYPE_SET_SPAN:
        case Action.TYPE_REMOVE_SPAN:
        case Action.TYPE_SET_HANDLER:
          onImeSynchronize();
          break;

        case Action.TYPE_REPLACE_TEXT:
          // try key events first
          sendCharKeyEvents(action);

          // fall-through

        case Action.TYPE_COMPOSE_TEXT:
          onImeReplaceText(
              action.mStart,
              action.mEnd,
              action.mSequence.toString(),
              action.mType == Action.TYPE_COMPOSE_TEXT);
          break;

        case Action.TYPE_ACKNOWLEDGE_FOCUS:
          onImeAcknowledgeFocus();
          break;

        default:
          throw new IllegalStateException("Action not processed");
      }

      ++mIcUpdateSeqno;
    }
 @Override
 public void run() {
   logger.info("begin to consume tweets");
   controller.running();
   while (true) {
     susSem.acquireUninterruptibly();
     try {
       for (Entry<String, List<Status>> topicData : consumer.nextStatus().entrySet()) {
         try {
           // 在高速转发的情况下,这样可以减轻写入到kafka中的状态数据
           Map<String, TimeSeriesUpdateState> states =
               new HashMap<String, TimeSeriesUpdateState>();
           List<TimeSeriesUpdateState> segSignal = new ArrayList<TimeSeriesUpdateState>();
           for (Status cur : topicData.getValue()) {
             tweetDao.putTweet(cur);
             if (cur.getRetweetedStatus() != null) {
               // rand.nextFloat() < 0.01 &&
               if (tweetDao.getStatusByMid(cur.getRetweetedStatus().getMid()) == null) {
                 tweetDao.putTweet(cur.getRetweetedStatus());
               }
               tweetDao.putRtweet(cur);
               for (TimeSeriesUpdateState state : tweetDao.updateRtTimeSeries(cur)) {
                 states.put(state.getMid(), state);
               }
             } else {
               // maybe it is the first tweet or an indication
               // for end of monitoring
               if (cur.getMid() != null) {
                 SegState state = segDao.getSegState(cur.getMid());
                 if (state != null) {
                   long updateDate = DateUtil.roundByHour(System.currentTimeMillis());
                   segSignal.add(new TimeSeriesUpdateState(state.mid, updateDate, true));
                   List<String> mids = tweetDao.getRtMids(state.mid);
                   for (String rtMid : mids) {
                     segSignal.add(new TimeSeriesUpdateState(rtMid, updateDate, true));
                   }
                 }
               }
             }
           }
           for (TimeSeriesUpdateState state : segSignal) {
             states.put(state.mid, state);
           }
           for (TimeSeriesUpdateState state : states.values()) {
             logger.info("update time series " + state);
             producer.storeTsUpdateState(state);
           }
         } catch (Exception ex) {
           ex.printStackTrace();
         }
       }
     } finally {
       susSem.release();
     }
   }
 }
예제 #18
0
  public void queue(Thread t, String id, long timeoutMS) throws TimeoutException {
    WeightedQueue weightedQueue = getWeightedQueue(id);

    try {
      queueSize.release();
      try {
        weightedQueue.put(t, timeoutMS);
        // the scheduler will release us when a slot is available
      } catch (TimeoutException e) {
        queueSize.acquireUninterruptibly();
        throw e;
      } catch (InterruptedException e) {
        queueSize.acquireUninterruptibly();
        throw e;
      }
    } catch (InterruptedException e) {
      throw new RuntimeException("Interrupted while queueing requests", e);
    }
  }
예제 #19
0
 /**
  * Sets the stream state
  *
  * @param state
  */
 public void setState(StreamState state) {
   if (!this.state.equals(state)) {
     try {
       lock.acquireUninterruptibly();
       this.state = state;
     } finally {
       lock.release();
     }
   }
 }
예제 #20
0
파일: Main.java 프로젝트: huoex/java-sample
    public void run() {

      int number = start;

      while (number <= limit) {
        from.acquireUninterruptibly();
        System.out.println(getName() + ": " + number);
        number += step;
        to.release();
      }
    }
예제 #21
0
 public void startGLThread() {
   Log.d(TAG, "Thread started.");
   if (mTextureManager == null) {
     mTextureManager = new TextureManager();
   }
   if (mTextureManager.getSurfaceTexture() == null) {
     mThread = new Thread(SurfaceView.this);
     mRunning = true;
     mThread.start();
     mLock.acquireUninterruptibly();
   }
 }
예제 #22
0
 public void acquireWrite() {
   assert (!readLocks.contains(Thread.currentThread()));
   if (!lock.tryAcquire(MAX_PERMITS)) {
     WorkerThread.beginIO();
     lock.acquireUninterruptibly(MAX_PERMITS);
     WorkerThread.endIO();
   }
   synchronized (this) {
     assert (writeLock == null);
     writeLock = Thread.currentThread();
   }
 }
예제 #23
0
  private int[] sensibilidad(int[][] incidencia, int[] vectorT, int tipoHilo) {
    boolean habilitado = false;
    int[] producto;
    int[] resultado = null;

    while (!habilitado) {
      boolean negativo = false; // Bandera que detecta valores negativos en el vector

      producto = matriz_por_vector(incidencia, vectorT);
      resultado = suma_vectorial(producto, marcado);

      for (int j = 0; j < resultado.length; j++) {
        if (resultado[j] < 0) {
          negativo = true;
        }
      }

      // Finalizado el cálculo, si la transición está habilitada modifico el marcado, y despierto
      // al hilo asociado. Caso contrario, el hilo actual va a ir a su respectiva cola a esperar.
      if (!negativo) {
        habilitado = true;
      } else {
        // Aquí mando el hilo a la cola que corresponda, dependiendo si es un hilo de incio de línea
        // o un hilo común. También libero el semáforo de ingreso a monitor.
        if (tipoHilo == 1) {
          ingreso.release();
          colaInicial.acquireUninterruptibly();
          ingreso.acquireUninterruptibly(); // Me voy al final de la cola de ingreso al monitor
        } else if (tipoHilo == 0) {
          ingreso.release();
          colaComun.acquireUninterruptibly();
          ingreso.acquireUninterruptibly(); // Me voy al final de la cola de ingreso al monitor
        }
      }
    }

    return resultado;
  }
  @Test
  public void testQueuedJobRunsAfterShutdown() throws InterruptedException {
    OutOfBandScheduledExecutor scheduler = new OutOfBandScheduledExecutor();
    ExecutorService worker = Executors.newSingleThreadExecutor();
    try {
      PartitionedScheduledExecutor executor = new PartitionedScheduledExecutor(scheduler, worker);

      final Semaphore jobSemaphore = new Semaphore(0);
      final Semaphore testSemaphore = new Semaphore(0);

      executor.submit(
          new Callable<Void>() {

            @Override
            public Void call() throws Exception {
              testSemaphore.release();
              jobSemaphore.acquireUninterruptibly();
              return null;
            }
          });
      executor.submit(
          new Callable<Void>() {

            @Override
            public Void call() throws Exception {
              jobSemaphore.acquireUninterruptibly();
              return null;
            }
          });
      testSemaphore.acquireUninterruptibly();
      executor.shutdown();
      assertThat(executor.awaitTermination(100, MILLISECONDS), is(false));
      assertThat(executor.isShutdown(), is(true));
      assertThat(executor.isTerminated(), is(false));

      jobSemaphore.release();
      assertThat(executor.awaitTermination(100, MILLISECONDS), is(false));
      assertThat(executor.isShutdown(), is(true));
      assertThat(executor.isTerminated(), is(false));

      jobSemaphore.release();
      assertThat(executor.awaitTermination(2, MINUTES), is(true));
      assertThat(executor.isShutdown(), is(true));
      assertThat(executor.isTerminated(), is(true));

      assertThat(jobSemaphore.availablePermits(), is(0));
    } finally {
      worker.shutdown();
    }
  }
예제 #25
0
  protected void request_mktData(Company company) {
    Contract contract = company.create_contract();

    Vector<TagValue> mkt_data_options = new Vector<TagValue>();

    sem_oid.acquireUninterruptibly();

    OpenRequest or = new OpenRequest(company, -1);
    open_request_map.put(next_orderId, or);
    client.reqMktData(next_orderId, contract, null, true, mkt_data_options);
    next_orderId++;

    sem_oid.release();
  }
예제 #26
0
  public int remaining() {
    waiterSemaphore.acquireUninterruptibly();
    try {
      int ret = 0;

      for (Integer i : queue) {
        ret += i;
      }

      return ret;
    } finally {
      waiterSemaphore.release();
    }
  }
예제 #27
0
 void syncWithGecko() {
   if (DEBUG) {
     assertOnIcThread();
   }
   if (mFocused && !mActions.isEmpty()) {
     if (DEBUG) {
       Log.d(LOGTAG, "syncWithGecko blocking on thread " + Thread.currentThread().getName());
     }
     mActionsActive.acquireUninterruptibly();
     mActionsActive.release();
   } else if (DEBUG && !mFocused) {
     Log.d(LOGTAG, "skipped syncWithGecko (no focus)");
   }
 }
예제 #28
0
  public DataSet request_histData(Company company, int long_short_volatility) {

    Contract contract = company.create_contract();

    Vector<TagValue> mkt_data_options = new Vector<TagValue>();

    sem_oid.acquireUninterruptibly();
    OpenRequest or = new OpenRequest(company, long_short_volatility);
    open_request_map.put(next_orderId, or);

    this.date = Calendar.getInstance().getTime();
    if (long_short_volatility == 0)
      client.reqHistoricalData(
          next_orderId,
          contract,
          df_ib.format(this.date),
          "1800 S",
          "30 mins",
          "TRADES",
          1,
          1,
          mkt_data_options);
    else if (long_short_volatility == 1)
      client.reqHistoricalData(
          next_orderId,
          contract,
          df_ib.format(this.date),
          parent.data_period,
          parent.data_granularity,
          "TRADES",
          1,
          1,
          mkt_data_options);
    else
      client.reqHistoricalData(
          next_orderId,
          contract,
          df_ib.format(calendar.getTime()),
          "1 D",
          "1 hour",
          "TRADES",
          1,
          1,
          mkt_data_options);

    next_orderId++;
    sem_oid.release();
    return null;
  }
예제 #29
0
 @Test
 public void decodingShortUtf8Data() throws Exception {
   Semaphore semaphore = new Semaphore(0);
   String SHORT_UNICODE_TEXT = "Hello \uD83D\uDCA9 world";
   System.err.println("Starting test decodingShortUtf8Data()");
   Utf8DecodingListener processListener = new Utf8DecodingListener(semaphore, SHORT_UNICODE_TEXT);
   NuProcessBuilder pb = new NuProcessBuilder(processListener, command);
   pb.start();
   semaphore.acquireUninterruptibly();
   Assert.assertEquals(
       "Decoding mismatch", SHORT_UNICODE_TEXT, processListener.decodedStdout.toString());
   Assert.assertEquals("Exit code mismatch", 0, processListener.exitCode);
   Assert.assertFalse("Decoder stdin should not overflow", processListener.stdinOverflow);
   System.err.println("Completed test decodingShortUtf8Data()");
 }
 /** Writes the raw packet data to the data stream. */
 public void writePacketData(PacketBuffer data) throws IOException {
   if (this.field_149281_e == null) {
     deflateGate.acquireUninterruptibly();
     if (this.field_149281_e == null) {
       deflate();
     }
     deflateGate.release();
   }
   data.writeInt(this.field_149284_a);
   data.writeInt(this.field_149282_b);
   data.writeBoolean(this.field_149279_g);
   data.writeShort((short) (this.field_149283_c & 65535));
   data.writeShort((short) (this.field_149280_d & 65535));
   data.writeInt(this.field_149285_h);
   data.writeBytes(this.field_149281_e, 0, this.field_149285_h);
 }