Example usage for java.util.concurrent.atomic AtomicBoolean set

List of usage examples for java.util.concurrent.atomic AtomicBoolean set

  1. HOME
  2. Java
  3. java
  4. java.util.concurrent.atomic.*
  5. AtomicBoolean
  6. set

Introduction

In this page you can find the example usage for java.util.concurrent.atomic AtomicBoolean set.

Prototype

public final void set(boolean newValue)

Source Link

Document

Sets the value to newValue , with memory effects as specified by VarHandle#setVolatile .

Usage

From source file:org.jooq.example.TransactionTest.java

@Test
public void testjOOQTransactionsNested() {
    AtomicBoolean rollback1 = new AtomicBoolean(false);
    AtomicBoolean rollback2 = new AtomicBoolean(false);

    try {//from   w ww  .  ja  va  2  s  . co m

        // If using Spring transactions, we don't need the c1 reference
        dsl.transaction(c1 -> {

            // The first insertion will work
            dsl.insertInto(BOOK).set(BOOK.ID, 5).set(BOOK.AUTHOR_ID, 1).set(BOOK.TITLE, "Book 5").execute();

            assertEquals(5, dsl.fetchCount(BOOK));

            try {

                // Nest transactions using Spring. This should create a savepoint, right here
                // If using Spring transactions, we don't need the c2 reference
                dsl.transaction(c2 -> {

                    // The second insertion shouldn't work
                    for (int i = 0; i < 2; i++)
                        dsl.insertInto(BOOK).set(BOOK.ID, 6).set(BOOK.AUTHOR_ID, 1).set(BOOK.TITLE, "Book 6")
                                .execute();

                    Assert.fail();
                });
            }

            catch (DataAccessException e) {
                rollback1.set(true);
            }

            // We should've rolled back to the savepoint
            assertEquals(5, dsl.fetchCount(BOOK));

            throw new org.jooq.exception.DataAccessException("Rollback");
        });
    }

    // Upon the constraint violation, the transaction must already have been rolled back
    catch (org.jooq.exception.DataAccessException e) {
        assertEquals("Rollback", e.getMessage());
        rollback2.set(true);
    }

    assertEquals(4, dsl.fetchCount(BOOK));
    assertTrue(rollback2.get());
    assertTrue(rollback2.get());
}

From source file:com.example.android.supportv7.util.DiffUtilActivity.java

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    LinearLayout ll = new LinearLayout(this);
    RecyclerView rv = new RecyclerView(this);
    Button shuffle = new Button(this);
    shuffle.setText("Shuffle");
    ll.addView(shuffle);//from w  w w  .  j av  a  2s . com
    ll.addView(rv);
    rv.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
            ViewGroup.LayoutParams.MATCH_PARENT));
    rv.setLayoutManager(new LinearLayoutManager(this));
    List<String> cheeseList = createRandomCheeseList(Collections.<String>emptyList(), 50);
    final SimpleStringAdapter adapter = new SimpleStringAdapter(this,
            cheeseList.toArray(new String[cheeseList.size()]));
    rv.setAdapter(adapter);
    final AtomicBoolean refreshingList = new AtomicBoolean(false);
    shuffle.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            if (refreshingList.getAndSet(true)) {
                // already refreshing, do not allow modifications
                return;
            }
            //noinspection unchecked
            new AsyncTask<List<String>, Void, Pair<List<String>, DiffUtil.DiffResult>>() {

                @Override
                protected Pair<List<String>, DiffUtil.DiffResult> doInBackground(List<String>... lists) {
                    List<String> oldList = lists[0];
                    List<String> newList = createRandomCheeseList(oldList, 5);
                    DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new MyCallback(oldList, newList));
                    //noinspection unchecked
                    return new Pair(newList, diffResult);
                }

                @Override
                protected void onPostExecute(Pair<List<String>, DiffUtil.DiffResult> resultPair) {
                    refreshingList.set(false);
                    adapter.setValues(resultPair.first);
                    resultPair.second.dispatchUpdatesTo(adapter);
                    Toast.makeText(DiffUtilActivity.this, "new list size " + resultPair.first.size(),
                            Toast.LENGTH_SHORT).show();
                }
            }.execute(adapter.getValues());

        }
    });
    setContentView(ll);
}

From source file:com.netflix.dyno.connectionpool.impl.lb.CircularListTest.java

@Test
public void testMultipleThreadsWithElementAdd() throws Exception {

    final AtomicBoolean stop = new AtomicBoolean(false);
    final CyclicBarrier barrier = new CyclicBarrier(5);
    final List<Future<Map<Integer, Integer>>> futures = new ArrayList<Future<Map<Integer, Integer>>>();

    for (int i = 0; i < 5; i++) {
        futures.add(threadPool.submit(new Callable<Map<Integer, Integer>>() {

            @Override//from w  ww.j  ava2 s  .  c om
            public Map<Integer, Integer> call() throws Exception {

                barrier.await();

                TestWorker worker = new TestWorker();

                while (!stop.get()) {
                    worker.process();
                }

                return worker.map;
            }
        }));
    }

    Thread.sleep(200);

    List<Integer> newList = new ArrayList<Integer>(iList);
    for (int i = 10; i < 15; i++) {
        newList.add(i);
    }

    cList.swapWithList(newList);

    Thread.sleep(200);
    stop.set(true);

    Map<Integer, Integer> result = getTotalMap(futures);

    Map<Integer, Integer> subMap = CollectionUtils.filterKeys(result, new Predicate<Integer>() {
        @Override
        public boolean apply(Integer input) {
            return input < 10;
        }
    });

    checkValues(new ArrayList<Integer>(subMap.values()));

    subMap = CollectionUtils.difference(result, subMap).entriesOnlyOnLeft();
    checkValues(new ArrayList<Integer>(subMap.values()));
}

From source file:ch.cyberduck.ui.cocoa.PromptLimitedListProgressListener.java

@Override
public void chunk(final Path parent, final AttributedList<Path> list) throws ListCanceledException {
    if (suppressed) {
        return;//ww  w  . j a v  a 2  s  .com
    }
    try {
        super.chunk(parent, list);
    } catch (ListCanceledException e) {
        if (controller.isVisible()) {
            final AtomicBoolean c = new AtomicBoolean(true);
            final NSAlert alert = NSAlert.alert(
                    MessageFormat.format(LocaleFactory.localizedString("Listing directory {0}", "Status"),
                            StringUtils.EMPTY),
                    MessageFormat.format(
                            LocaleFactory.localizedString(
                                    "Continue listing directory with more than {0} files.", "Alert"),
                            e.getChunk().size()),
                    LocaleFactory.localizedString("Continue", "Credentials"), null,
                    LocaleFactory.localizedString("Cancel"));
            alert.setShowsSuppressionButton(true);
            alert.suppressionButton().setTitle(LocaleFactory.localizedString("Always"));
            final AlertController sheet = new AlertController(controller, alert) {
                @Override
                public void callback(final int returncode) {
                    if (returncode == SheetCallback.DEFAULT_OPTION) {
                        suppressed = true;
                    }
                    if (returncode == SheetCallback.CANCEL_OPTION) {
                        c.set(false);
                    }
                    if (alert.suppressionButton().state() == NSCell.NSOnState) {
                        disable();
                    }
                }
            };
            sheet.beginSheet();
            if (!c.get()) {
                throw e;
            }
        }
    }
}

From source file:org.apache.bookkeeper.bookie.CreateNewLogTest.java

@Test
public void testCreateNewLogAndCompactionLog() throws Exception {
    ServerConfiguration conf = TestBKConfiguration.newServerConfiguration();

    // Creating a new configuration with a number of
    // ledger directories.
    conf.setLedgerDirNames(ledgerDirs);//from   www  .jav a  2s. c o  m
    conf.setEntryLogFilePreAllocationEnabled(true);
    LedgerDirsManager ledgerDirsManager = new LedgerDirsManager(conf, conf.getLedgerDirs(),
            new DiskChecker(conf.getDiskUsageThreshold(), conf.getDiskUsageWarnThreshold()));
    EntryLogger el = new EntryLogger(conf, ledgerDirsManager);
    // set same thread executor for entryLoggerAllocator's allocatorExecutor
    setSameThreadExecutorForEntryLoggerAllocator(el.getEntryLoggerAllocator());
    AtomicBoolean receivedException = new AtomicBoolean(false);

    IntStream.range(0, 2).parallel().forEach((i) -> {
        try {
            if (i % 2 == 0) {
                ((EntryLogManagerBase) el.getEntryLogManager()).createNewLog((long) i);
            } else {
                el.createNewCompactionLog();
            }
        } catch (IOException e) {
            LOG.error("Received exception while creating newLog", e);
            receivedException.set(true);
        }
    });

    Assert.assertFalse("There shouldn't be any exceptions while creating newlog", receivedException.get());
    Assert.assertEquals("previousAllocatedEntryLogId after 2 times createNewLog is called", 2,
            el.getPreviousAllocatedEntryLogId());
}

From source file:com.bt.aloha.media.testing.mockphones.ConvediaMockphoneBean.java

private void processMsmlCancelMediaRequest(final String dialogId, final String commandId) {
    final AtomicBoolean needToSendDtmfTerminatedResponse = new AtomicBoolean(false);
    final DialogInfo dialogInfo = getDialogCollection().get(dialogId);
    String originalAudioFileUri = dialogInfo.getApplicationData();
    String responseContent = null;
    if (originalAudioFileUri.indexOf(PLAY_TERMINATED_STRING_PROPERTY_KEY) > -1) {
        responseContent = new MsmlAnnouncementResponse(commandId, ONE_HUNDRED_MS, PLAY_TERMINATED).getXml();
    } else if (originalAudioFileUri.indexOf(DTMF_PLAY_TERMINATED_STRING_PROPERTY_KEY) > -1) {
        responseContent = new MsmlPromptAndCollectDigitsAnnouncementResponse(commandId, ONE_HUNDRED_MS,
                PLAY_TERMINATED).getXml();
    } else if (originalAudioFileUri.indexOf(DTMF_TERMINATED_STRING_PROPERTY_KEY) > -1) {
        responseContent = new MsmlPromptAndCollectDigitsAnnouncementResponse(commandId, ONE_HUNDRED_MS,
                "play.complete").getXml();
        needToSendDtmfTerminatedResponse.set(true);
    }//ww w. j  a va  2s .c  o  m
    sendMediaResponse(dialogId, commandId, responseContent);

    if (needToSendDtmfTerminatedResponse.get()) {
        responseContent = new MsmlPromptAndCollectDigitsCollectedResponse(commandId, ONE_HUNDRED_MS,
                "dtmf.terminated").getXml();
        sendMediaResponse(dialogId, commandId, responseContent);
    }
}

From source file:com.igormaznitsa.jcp.utils.PreprocessorUtils.java

@Nonnull
@MustNotContainNull/*from   w  w  w .  j a  va  2 s  .  co  m*/
public static String[] readWholeTextFileIntoArray(@Nonnull final File file, @Nullable final String encoding,
        @Nullable final AtomicBoolean endedByNextLine) throws IOException {
    checkFile(file);

    final String enc = encoding == null ? "UTF8" : encoding;

    final BufferedReader srcBufferedReader = PreprocessorUtils.makeFileReader(file, enc, (int) file.length());
    final List<String> strContainer = new ArrayList<String>(1024);
    try {
        final StringBuilder buffer = new StringBuilder();

        boolean stringEndedByNextLine = false;

        boolean meetCR = false;

        while (true) {
            final int chr = srcBufferedReader.read();
            if (chr < 0) {
                break;
            }

            switch (chr) {
            case '\n': {
                stringEndedByNextLine = true;
                strContainer.add(buffer.toString());
                buffer.setLength(0);
                meetCR = false;
            }
                break;
            case '\r': {
                if (meetCR) {
                    buffer.append((char) chr);
                } else {
                    stringEndedByNextLine = false;
                    meetCR = true;
                }
            }
                break;
            default: {
                if (meetCR) {
                    buffer.append('\r');
                }
                meetCR = false;
                stringEndedByNextLine = false;
                buffer.append((char) chr);
            }
                break;
            }
        }

        if (buffer.length() != 0) {
            strContainer.add(buffer.toString());
            buffer.setLength(0);
        }

        if (endedByNextLine != null) {
            endedByNextLine.set(stringEndedByNextLine);
        }
    } finally {
        srcBufferedReader.close();
    }

    return strContainer.toArray(new String[strContainer.size()]);
}

From source file:com.turbospaces.model.BO.java

/**
 * create business object over actual basic persistent entity
 * /*from w  ww  . ja v  a 2s  . c o  m*/
 * @param delegate
 *            the actual persistent entity meta-data provider
 * @throws NoSuchMethodException
 *             re-throw cglib exception
 * @throws SecurityException
 *             re-throw cglib exception
 * @throws IntrospectionException
 *             re-throw exceptions
 */
public BO(final BasicPersistentEntity delegate)
        throws SecurityException, NoSuchMethodException, IntrospectionException {
    this.delegate = delegate;
    this.fastConstructor = FastClass.create(delegate.getType())
            .getConstructor(delegate.getType().getConstructor());

    // find optimistic lock version/routing fields
    {
        final Collection<PersistentProperty> versionCandidates = Lists.newLinkedList();
        final Collection<PersistentProperty> routingCandidates = Lists.newLinkedList();
        delegate.doWithProperties(new PropertyHandler() {
            @Override
            public void doWithPersistentProperty(final PersistentProperty persistentProperty) {
                PropertyDescriptor propertyDescriptor = persistentProperty.getPropertyDescriptor();
                Field field = persistentProperty.getField();

                if (hasAnnotation(propertyDescriptor, field, Version.class))
                    versionCandidates.add(persistentProperty);
                if (hasAnnotation(propertyDescriptor, field, Routing.class))
                    routingCandidates.add(persistentProperty);
            }

            private boolean hasAnnotation(final PropertyDescriptor descriptor, final Field field,
                    final Class annotation) {
                if (descriptor != null && descriptor.getReadMethod() != null
                        && descriptor.getReadMethod().getAnnotation(annotation) != null)
                    return true;
                if (field != null && field.getAnnotation(annotation) != null)
                    return true;
                return false;
            }
        });
        Preconditions.checkArgument(versionCandidates.size() <= 1,
                "too many fields marked with @Version annotation, candidates = "
                        + versionCandidates.toString());
        Preconditions.checkArgument(routingCandidates.size() <= 1,
                "too many fields marked with @Routing annotation, candidates = "
                        + routingCandidates.toString());

        if (!versionCandidates.isEmpty())
            optimisticLockVersionProperty = versionCandidates.iterator().next();
        if (!routingCandidates.isEmpty())
            routingProperty = routingCandidates.iterator().next();
    }

    {
        // Java Beans convention marker
        AtomicBoolean propertyAccess = new AtomicBoolean(true);

        List<String> setters = Lists.newLinkedList();
        List<String> getters = Lists.newLinkedList();
        List<Class<?>> types = Lists.newLinkedList();

        for (PersistentProperty<?> persistentProperty : getOrderedProperties()) {
            PropertyDescriptor propertyDescriptor = persistentProperty.getPropertyDescriptor();
            if (propertyDescriptor != null) {
                if (propertyDescriptor.getReadMethod() != null && propertyDescriptor.getWriteMethod() != null) {
                    setters.add(propertyDescriptor.getWriteMethod().getName());
                    getters.add(propertyDescriptor.getReadMethod().getName());
                    types.add(persistentProperty.getType());
                }
            } else {
                propertyAccess.set(false);
                brokenProperties.add(persistentProperty);
            }
        }

        if (propertyAccess.get())
            // create properties extract for all persistent properties
            bulkBean = BulkBean.create(delegate.getType(), getters.toArray(new String[getters.size()]),
                    setters.toArray(new String[setters.size()]), types.toArray(new Class[types.size()]));
        else
            Log.warn(String.format(
                    "PropetiesSerializer-%s unable to use getters-setters access optimization. Suspected/Corrupted properties = %s",
                    delegate.getType().getSimpleName(), getBrokenProperties()));

        boolean canOptimizeIdProperty = hasReadWriteMethods(delegate.getIdProperty());
        boolean canOptimizeVersionProperty = hasReadWriteMethods(getOptimisticLockVersionProperty());
        boolean canOptimizeRoutingProperty = hasReadWriteMethods(getRoutingProperty());

        // create id/version/routing bulk fields extractor
        if (canOptimizeIdProperty && canOptimizeVersionProperty && canOptimizeRoutingProperty) {
            String[] g = new String[] {
                    delegate.getIdProperty().getPropertyDescriptor().getReadMethod().getName(),
                    getOptimisticLockVersionProperty().getPropertyDescriptor().getReadMethod().getName(),
                    getRoutingProperty().getPropertyDescriptor().getReadMethod().getName() };
            String[] s = new String[] {
                    delegate.getIdProperty().getPropertyDescriptor().getWriteMethod().getName(),
                    getOptimisticLockVersionProperty().getPropertyDescriptor().getWriteMethod().getName(),
                    getRoutingProperty().getPropertyDescriptor().getWriteMethod().getName() };
            Class<?>[] c = new Class[] { delegate.getIdProperty().getType(),
                    getOptimisticLockVersionProperty().getType(), getRoutingProperty().getType() };

            idVersionRoutingBulkBean = BulkBean.create(delegate.getType(), g, s, c);
        }
    }
}

From source file:org.apache.tinkerpop.gremlin.server.GremlinDriverIntegrateTest.java

@Test
public void shouldProcessSessionRequestsInOrder() throws Exception {
    final Cluster cluster = Cluster.open();
    final Client client = cluster.connect(name.getMethodName());

    final ResultSet rsFive = client.submit("Thread.sleep(5000);'five'");
    final ResultSet rsZero = client.submit("'zero'");

    final CompletableFuture<List<Result>> futureFive = rsFive.all();
    final CompletableFuture<List<Result>> futureZero = rsZero.all();

    final AtomicBoolean hit = new AtomicBoolean(false);
    while (!futureFive.isDone()) {
        // futureZero can't finish before futureFive - racy business here?
        assertThat(futureZero.isDone(), is(false));
        hit.set(true);
    }//  www .  j a v a 2  s.com

    // should have entered the loop at least once and thus proven that futureZero didn't return ahead of
    // futureFive
    assertThat(hit.get(), is(true));

    assertEquals("zero", futureZero.get().get(0).getString());
    assertEquals("five", futureFive.get(10, TimeUnit.SECONDS).get(0).getString());
}

From source file:io.atomix.protocols.gossip.map.AntiEntropyMapDelegate.java

private MapValue removeInternal(String key, Optional<byte[]> value, Optional<MapValue> tombstone) {
    checkState(!closed, destroyedMessage);
    checkNotNull(key, ERROR_NULL_KEY);// w w w. j av a 2s .  co  m
    checkNotNull(value, ERROR_NULL_VALUE);
    tombstone.ifPresent(v -> checkState(v.isTombstone()));

    counter.incrementCount();
    AtomicBoolean updated = new AtomicBoolean(false);
    AtomicReference<MapValue> previousValue = new AtomicReference<>();
    items.compute(key, (k, existing) -> {
        boolean valueMatches = true;
        if (value.isPresent() && existing != null && existing.isAlive()) {
            valueMatches = Arrays.equals(value.get(), existing.get());
        }
        if (existing == null) {
            log.trace("ECMap Remove: Existing value for key {} is already null", k);
        }
        if (valueMatches) {
            if (existing == null) {
                updated.set(tombstone.isPresent());
            } else {
                updated.set(!tombstone.isPresent() || tombstone.get().isNewerThan(existing));
            }
        }
        if (updated.get()) {
            previousValue.set(existing);
            return tombstone.orElse(null);
        } else {
            return existing;
        }
    });
    return previousValue.get();
}