Examples of java.util.concurrent.atomic.AtomicLong

java.util.concurrent.atomic.AtomicLong
GWT emulated version of {@link AtomicLong}. It's a thin wrapper around the primitive {@code long}. @author Jige Yu

      }
    };
    File file = File.createTempFile("post", ".txt");
    new FileWriter(file).append("hello").close();
    InputStream input = new FileInputStream(file);
    final AtomicLong tx = new AtomicLong(0);
    UploadProgress progress = new UploadProgress() {
      public void onUpload(long transferred, long total) {
        assertEquals(-1, total);
        assertEquals(tx.incrementAndGet(), transferred);
      }
    };
    post(url).bufferSize(1).progress(progress).send(input).code();
    assertEquals(file.length(), tx.get());
  }

View Full Code Here

        response.setStatus(HTTP_OK);
      }
    };


    final byte[] bytes = "hello".getBytes(CHARSET_UTF8);
    final AtomicLong tx = new AtomicLong(0);
    UploadProgress progress = new UploadProgress() {
      public void onUpload(long transferred, long total) {
        assertEquals(bytes.length, total);
        assertEquals(tx.incrementAndGet(), transferred);
      }
    };
    post(url).bufferSize(1).progress(progress).send(bytes).code();
    assertEquals(bytes.length, tx.get());
  }

View Full Code Here

        body.set(new String(read()));
        response.setStatus(HTTP_OK);
      }
    };


    final AtomicLong tx = new AtomicLong(0);
    UploadProgress progress = new UploadProgress() {
      public void onUpload(long transferred, long total) {
        assertEquals(-1, total);
        assertEquals(tx.incrementAndGet(), transferred);
      }
    };
    File file = File.createTempFile("post", ".txt");
    new FileWriter(file).append("hello").close();
    post(url).progress(progress).bufferSize(1).send(new FileReader(file)).code();
    assertEquals(file.length(), tx.get());
  }

View Full Code Here


      filesRepository.calculateNextfileID(orderedFiles);


      int lastDataPos = JournalImpl.SIZE_HEADER;


      final AtomicLong maxID = new AtomicLong(-1);


      for (final JournalFile file : orderedFiles)
      {
         JournalImpl.trace("Loading file " + file.getFile().getFileName());


         final AtomicBoolean hasData = new AtomicBoolean(false);


         int resultLastPost = JournalImpl.readJournalFile(fileFactory, file, new JournalReaderCallback()
         {


            private void checkID(final long id)
            {
               if (id > maxID.longValue())
               {
                  maxID.set(id);
               }
            }


            public void onReadAddRecord(final RecordInfo info) throws Exception
            {
               checkID(info.id);


               hasData.set(true);


               loadManager.addRecord(info);


               records.put(info.id, new JournalRecord(file, info.data.length + JournalImpl.SIZE_ADD_RECORD + 1));
            }


            public void onReadUpdateRecord(final RecordInfo info) throws Exception
            {
               checkID(info.id);


               hasData.set(true);


               loadManager.updateRecord(info);


               JournalRecord posFiles = records.get(info.id);


               if (posFiles != null)
               {
                  // It's legal for this to be null. The file(s) with the may
                  // have been deleted
                  // just leaving some updates in this file


                  posFiles.addUpdateFile(file, info.data.length + JournalImpl.SIZE_ADD_RECORD + 1); // +1 = compact
                  // count
               }
            }


            public void onReadDeleteRecord(final long recordID) throws Exception
            {
               hasData.set(true);


               loadManager.deleteRecord(recordID);


               JournalRecord posFiles = records.remove(recordID);


               if (posFiles != null)
               {
                  posFiles.delete(file);
               }
            }


            public void onReadUpdateRecordTX(final long transactionID, final RecordInfo info) throws Exception
            {
               onReadAddRecordTX(transactionID, info);
            }


            public void onReadAddRecordTX(final long transactionID, final RecordInfo info) throws Exception
            {


               checkID(info.id);


               hasData.set(true);


               TransactionHolder tx = loadTransactions.get(transactionID);


               if (tx == null)
               {
                  tx = new TransactionHolder(transactionID);


                  loadTransactions.put(transactionID, tx);
               }


               tx.recordInfos.add(info);


               JournalTransaction tnp = transactions.get(transactionID);


               if (tnp == null)
               {
                  tnp = new JournalTransaction(transactionID, JournalImpl.this);


                  transactions.put(transactionID, tnp);
               }


               tnp.addPositive(file, info.id, info.data.length + JournalImpl.SIZE_ADD_RECORD_TX + 1); // +1 = compact
               // count
            }


            public void onReadDeleteRecordTX(final long transactionID, final RecordInfo info) throws Exception
            {
               hasData.set(true);


               TransactionHolder tx = loadTransactions.get(transactionID);


               if (tx == null)
               {
                  tx = new TransactionHolder(transactionID);


                  loadTransactions.put(transactionID, tx);
               }


               tx.recordsToDelete.add(info);


               JournalTransaction tnp = transactions.get(transactionID);


               if (tnp == null)
               {
                  tnp = new JournalTransaction(transactionID, JournalImpl.this);


                  transactions.put(transactionID, tnp);
               }


               tnp.addNegative(file, info.id);


            }


            public void onReadPrepareRecord(final long transactionID, final byte[] extraData, final int numberOfRecords) throws Exception
            {
               hasData.set(true);


               TransactionHolder tx = loadTransactions.get(transactionID);


               if (tx == null)
               {
                  // The user could choose to prepare empty transactions
                  tx = new TransactionHolder(transactionID);


                  loadTransactions.put(transactionID, tx);
               }


               tx.prepared = true;


               tx.extraData = extraData;


               JournalTransaction journalTransaction = transactions.get(transactionID);


               if (journalTransaction == null)
               {
                  journalTransaction = new JournalTransaction(transactionID, JournalImpl.this);


                  transactions.put(transactionID, journalTransaction);
               }


               boolean healthy = checkTransactionHealth(file, journalTransaction, orderedFiles, numberOfRecords);


               if (healthy)
               {
                  journalTransaction.prepare(file);
               }
               else
               {
                  JournalImpl.log.warn("Prepared transaction " + transactionID +
                                       " wasn't considered completed, it will be ignored");
                  tx.invalid = true;
               }
            }


            public void onReadCommitRecord(final long transactionID, final int numberOfRecords) throws Exception
            {
               TransactionHolder tx = loadTransactions.remove(transactionID);


               // The commit could be alone on its own journal-file and the
               // whole transaction body was reclaimed but not the
               // commit-record
               // So it is completely legal to not find a transaction at this
               // point
               // If we can't find it, we assume the TX was reclaimed and we
               // ignore this
               if (tx != null)
               {
                  JournalTransaction journalTransaction = transactions.remove(transactionID);


                  if (journalTransaction == null)
                  {
                     throw new IllegalStateException("Cannot find tx " + transactionID);
                  }


                  boolean healthy = checkTransactionHealth(file, journalTransaction, orderedFiles, numberOfRecords);


                  if (healthy)
                  {
                     for (RecordInfo txRecord : tx.recordInfos)
                     {
                        if (txRecord.isUpdate)
                        {
                           loadManager.updateRecord(txRecord);
                        }
                        else
                        {
                           loadManager.addRecord(txRecord);
                        }
                     }


                     for (RecordInfo deleteValue : tx.recordsToDelete)
                     {
                        loadManager.deleteRecord(deleteValue.id);
                     }


                     journalTransaction.commit(file);
                  }
                  else
                  {
                     JournalImpl.log.warn("Transaction " + transactionID +
                                          " is missing elements so the transaction is being ignored");


                     journalTransaction.forget();
                  }


                  hasData.set(true);
               }


            }


            public void onReadRollbackRecord(final long transactionID) throws Exception
            {
               TransactionHolder tx = loadTransactions.remove(transactionID);


               // The rollback could be alone on its own journal-file and the
               // whole transaction body was reclaimed but the commit-record
               // So it is completely legal to not find a transaction at this
               // point
               if (tx != null)
               {
                  JournalTransaction tnp = transactions.remove(transactionID);


                  if (tnp == null)
                  {
                     throw new IllegalStateException("Cannot find tx " + transactionID);
                  }


                  // There is no need to validate summaries/holes on
                  // Rollbacks.. We will ignore the data anyway.
                  tnp.rollback(file);


                  hasData.set(true);
               }
            }


            public void markAsDataFile(final JournalFile file)
            {
               hasData.set(true);
            }


         });


         if (hasData.get())
         {
            lastDataPos = resultLastPost;
            filesRepository.addDataFileOnBottom(file);
         }
         else
         {
            // Empty dataFiles with no data
            filesRepository.addFreeFileNoInit(file);
         }
      }


      // Create any more files we need


      filesRepository.ensureMinFiles();


      // The current file is the last one that has data


      currentFile = filesRepository.pollLastDataFile();


      if (currentFile != null)
      {
         currentFile.getFile().open();


         currentFile.getFile().position(currentFile.getFile().calculateBlockStart(lastDataPos));
      }
      else
      {
         currentFile = filesRepository.getFreeFile();


         filesRepository.openFile(currentFile, true);
      }


      fileFactory.activateBuffer(currentFile.getFile());


      filesRepository.pushOpenedFile();


      state = JournalImpl.STATE_LOADED;


      for (TransactionHolder transaction : loadTransactions.values())
      {
         if (!transaction.prepared || transaction.invalid)
         {
            JournalImpl.log.warn("Uncommitted transaction with id " + transaction.transactionID +
                                 " found and discarded");


            if (fixFailingTransactions)
            {
               // I append a rollback record here, because otherwise compacting will be throwing messages because of unknown transactions
               this.appendRollbackRecord(transaction.transactionID, false);
            }


            loadManager.failedTransaction(transaction.transactionID,
                                          transaction.recordInfos,
                                          transaction.recordsToDelete);
         }
         else
         {
            for (RecordInfo info : transaction.recordInfos)
            {
               if (info.id > maxID.get())
               {
                  maxID.set(info.id);
               }
            }


            PreparedTransactionInfo info = new PreparedTransactionInfo(transaction.transactionID, transaction.extraData);


            info.records.addAll(transaction.recordInfos);


            info.recordsToDelete.addAll(transaction.recordsToDelete);


            loadManager.addPreparedTransaction(info);
         }
      }


      checkReclaimStatus();


      return new JournalLoadInformation(records.size(), maxID.longValue());
   }

View Full Code Here

        this.metricRegistry = metricRegistry;
        if (Message.RESERVED_FIELDS.contains(targetField) && !Message.RESERVED_SETTABLE_FIELDS.contains(targetField)) {
            throw new ReservedFieldException("You cannot apply an extractor on reserved field [" + targetField + "].");
        }


        this.exceptions = new AtomicLong(0);
        this.converterExceptions = new AtomicLong(0);


        this.id = id;
        this.title = title;
        this.order = order;
        this.superType = type;

View Full Code Here


        TestServlet servlet1 = new TestServlet(initLatch, destroyLatch)
        {
            private static final long serialVersionUID = 1L;


            final AtomicLong m_count = new AtomicLong();


            @Override
            protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
            {
                resp.setStatus(SC_OK);
                resp.getWriter().printf("1.%d", m_count.incrementAndGet());
                resp.flushBuffer();
            }
        };


        TestServlet servlet2 = new TestServlet(initLatch, destroyLatch)
        {
            private static final long serialVersionUID = 1L;


            final AtomicLong m_count = new AtomicLong();


            @Override
            protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
            {
                resp.setStatus(SC_OK);
                resp.getWriter().printf("2.%d", m_count.incrementAndGet());
                resp.flushBuffer();
            }
        };


        TestFilter filter = new TestFilter(initLatch, destroyLatch)

View Full Code Here

    private long participationTimeOut = 60 * 1000L;


    CoordinationMgr()
    {
        perThreadStack = new ThreadLocal<Stack<CoordinationImpl>>();
        ctr = new AtomicLong(-1);
        coordinations = new HashMap<Long, CoordinationImpl>();
        participants = new IdentityHashMap<Participant, CoordinationImpl>();
        coordinationTimer = new Timer("Coordination Timer", true);
    }

View Full Code Here


    @Override
    protected void doStart() throws Exception {
        task = new TimerTask() {
            // counter
            private final AtomicLong counter = new AtomicLong();


            @Override
            public void run() {
                if (!isTaskRunAllowed()) {
                    // do not run timer task as it was not allowed
                    LOG.debug("Run now allowed for timer: {}", endpoint);
                    return;
                }


                try {
                    long count = counter.incrementAndGet();


                    boolean fire = endpoint.getRepeatCount() <= 0 || count <= endpoint.getRepeatCount();
                    if (fire) {
                        sendTimerExchange(count);
                    } else {

View Full Code Here


    public Result() {
        count = new AtomicInteger();
        ignoreCount = new AtomicInteger();
        failures = new CopyOnWriteArrayList<Failure>();
        runTime = new AtomicLong();
        startTime = new AtomicLong();
    }

View Full Code Here


    private Result(SerializedForm serializedForm) {
        count = serializedForm.fCount;
        ignoreCount = serializedForm.fIgnoreCount;
        failures = new CopyOnWriteArrayList<Failure>(serializedForm.fFailures);
        runTime = new AtomicLong(serializedForm.fRunTime);
        startTime = new AtomicLong(serializedForm.fStartTime);
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.atomic.AtomicLong

backtype.storm.utils.Time

com.addthis.codec.CodecJSON

com.alibaba.otter.canal.parse.inbound.mysql.MysqlEventParser

com.alibaba.rocketmq.client.consumer.store.LocalFileOffsetStore

com.alibaba.rocketmq.client.impl.consumer.PullAPIWrapper

com.alibaba.rocketmq.namesrv.processor.DefaultRequestProcessor

com.alibaba.wasp.master.EntityGroupState

com.blogspot.ostas.monitoring.interceptor.PerformanceMonitoringInterceptor

com.cloudhopper.smpp.util.ConcurrentCommandCounter

com.facebook.presto.hive.util.AsyncRecursiveWalker

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.