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:com.eventsourcing.repository.RepositoryTest.java

@Test
@SneakyThrows/*from w  ww . j ava 2  s .c  om*/
public void subscribe() {
    final AtomicBoolean gotEvent = new AtomicBoolean();
    final AtomicBoolean gotCommand = new AtomicBoolean();
    repository.addEntitySubscriber(new ClassEntitySubscriber<TestEvent>(TestEvent.class) {
        @Override
        public void onEntity(EntityHandle<TestEvent> entity) {
            gotEvent.set(journal.get(entity.uuid()).isPresent());
        }
    });
    repository
            .addEntitySubscriber(new ClassEntitySubscriber<RepositoryTestCommand>(RepositoryTestCommand.class) {
                @Override
                public void onEntity(EntityHandle<RepositoryTestCommand> entity) {
                    gotCommand.set(journal.get(entity.uuid()).isPresent());
                }
            });
    repository.publish(RepositoryTestCommand.builder().build()).get();
    assertTrue(gotEvent.get());
    assertTrue(gotCommand.get());
}

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

@Test
public void testSingleThreadWithElementAdd() throws Exception {

    final AtomicBoolean stop = new AtomicBoolean(false);

    Future<Map<Integer, Integer>> future = threadPool.submit(new Callable<Map<Integer, Integer>>() {

        @Override//from w  w w  .  ja v  a 2  s  .c o  m
        public Map<Integer, Integer> call() throws Exception {

            TestWorker worker = new TestWorker();

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

            return worker.map;
        }
    });

    Thread.sleep(500);

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

    cList.swapWithList(newList);

    Thread.sleep(100);

    stop.set(true);

    Map<Integer, Integer> result = future.get();

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

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

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

From source file:com.facebook.AccessTokenManager.java

private void refreshCurrentAccessTokenImpl() {
    final AccessToken accessToken = currentAccessToken;
    if (accessToken == null) {
        return;/*from w ww  . j a  v  a2s  .c o  m*/
    }
    if (!tokenRefreshInProgress.compareAndSet(false, true)) {
        return;
    }

    Validate.runningOnUiThread();

    lastAttemptedTokenExtendDate = new Date();

    final Set<String> permissions = new HashSet<>();
    final Set<String> declinedPermissions = new HashSet<>();
    final AtomicBoolean permissionsCallSucceeded = new AtomicBoolean(false);
    final RefreshResult refreshResult = new RefreshResult();

    GraphRequestBatch batch = new GraphRequestBatch(
            createGrantedPermissionsRequest(accessToken, new GraphRequest.Callback() {
                @Override
                public void onCompleted(GraphResponse response) {
                    JSONObject result = response.getJSONObject();
                    if (result == null) {
                        return;
                    }
                    JSONArray permissionsArray = result.optJSONArray("data");
                    if (permissionsArray == null) {
                        return;
                    }
                    permissionsCallSucceeded.set(true);
                    for (int i = 0; i < permissionsArray.length(); i++) {
                        JSONObject permissionEntry = permissionsArray.optJSONObject(i);
                        if (permissionEntry == null) {
                            continue;
                        }
                        String permission = permissionEntry.optString("permission");
                        String status = permissionEntry.optString("status");
                        if (!Utility.isNullOrEmpty(permission) && !Utility.isNullOrEmpty(status)) {
                            status = status.toLowerCase(Locale.US);
                            if (status.equals("granted")) {
                                permissions.add(permission);
                            } else if (status.equals("declined")) {
                                declinedPermissions.add(permission);
                            } else {
                                Log.w(TAG, "Unexpected status: " + status);
                            }
                        }
                    }
                }
            }), createExtendAccessTokenRequest(accessToken, new GraphRequest.Callback() {
                @Override
                public void onCompleted(GraphResponse response) {
                    JSONObject data = response.getJSONObject();
                    if (data == null) {
                        return;
                    }
                    refreshResult.accessToken = data.optString("access_token");
                    refreshResult.expiresAt = data.optInt("expires_at");
                }
            }));

    batch.addCallback(new GraphRequestBatch.Callback() {
        @Override
        public void onBatchCompleted(GraphRequestBatch batch) {
            if (getInstance().getCurrentAccessToken() == null
                    || getInstance().getCurrentAccessToken().getUserId() != accessToken.getUserId()) {
                return;
            }
            try {
                if (permissionsCallSucceeded.get() == false && refreshResult.accessToken == null
                        && refreshResult.expiresAt == 0) {
                    return;
                }
                AccessToken newAccessToken = new AccessToken(
                        refreshResult.accessToken != null ? refreshResult.accessToken : accessToken.getToken(),
                        accessToken.getApplicationId(), accessToken.getUserId(),
                        permissionsCallSucceeded.get() ? permissions : accessToken.getPermissions(),
                        permissionsCallSucceeded.get() ? declinedPermissions
                                : accessToken.getDeclinedPermissions(),
                        accessToken.getSource(),
                        refreshResult.expiresAt != 0 ? new Date(refreshResult.expiresAt * 1000l)
                                : accessToken.getExpires(),
                        new Date());
                getInstance().setCurrentAccessToken(newAccessToken);
            } finally {
                tokenRefreshInProgress.set(false);
            }
        }
    });
    batch.executeAsync();
}

From source file:ch.entwine.weblounge.preview.phantomjs.PhantomJsPagePreviewGenerator.java

/**
 * {@inheritDoc}//from w  w w. j a v  a 2 s.  c om
 * 
 * @see ch.entwine.weblounge.common.content.PreviewGenerator#createPreview(ch.entwine.weblounge.common.content.Resource,
 *      ch.entwine.weblounge.common.site.Environment,
 *      ch.entwine.weblounge.common.language.Language,
 *      ch.entwine.weblounge.common.content.image.ImageStyle, String,
 *      java.io.InputStream, java.io.OutputStream)
 */
public void createPreview(Resource<?> resource, Environment environment, Language language, ImageStyle style,
        String format, InputStream is, OutputStream os) throws IOException {

    // We don't need the input stream
    IOUtils.closeQuietly(is);

    // Find a suitable image preview generator for scaling
    ImagePreviewGenerator imagePreviewGenerator = null;
    synchronized (previewGenerators) {
        for (ImagePreviewGenerator generator : previewGenerators) {
            if (generator.supports(format)) {
                imagePreviewGenerator = generator;
                break;
            }
        }
        if (imagePreviewGenerator == null) {
            logger.debug("Unable to generate page previews since no image renderer is available");
            return;
        }
    }

    // Find the relevant metadata to start the request
    ResourceURI uri = resource.getURI();
    long version = resource.getVersion();
    Site site = uri.getSite();

    // Create the url
    URL pageURL = new URL(UrlUtils.concat(site.getHostname(environment).toExternalForm(), PAGE_HANDLER_PREFIX,
            uri.getIdentifier()));
    if (version == Resource.WORK) {
        pageURL = new URL(
                UrlUtils.concat(pageURL.toExternalForm(), "work_" + language.getIdentifier() + ".html"));
    } else {
        pageURL = new URL(
                UrlUtils.concat(pageURL.toExternalForm(), "index_" + language.getIdentifier() + ".html"));
    }

    // Create a temporary file
    final File rendererdFile = File.createTempFile("phantomjs-", "." + format, phantomTmpDir);
    final URL finalPageURL = pageURL;
    final AtomicBoolean success = new AtomicBoolean();

    // Call PhantomJS to render the page
    try {
        final PhantomJsProcessExecutor phantomjs = new PhantomJsProcessExecutor(scriptFile.getAbsolutePath(),
                pageURL.toExternalForm(), rendererdFile.getAbsolutePath()) {
            @Override
            protected void onProcessFinished(int exitCode) throws IOException {
                super.onProcessFinished(exitCode);
                switch (exitCode) {
                case 0:
                    if (rendererdFile.length() > 0) {
                        success.set(true);
                        logger.debug("Page preview of {} created at {}", finalPageURL,
                                rendererdFile.getAbsolutePath());
                    } else {
                        logger.warn("Error creating page preview of {}", finalPageURL);
                        success.set(false);
                        FileUtils.deleteQuietly(rendererdFile);
                    }
                    break;
                default:
                    success.set(false);
                    logger.warn("Error creating page preview of {}", finalPageURL);
                    FileUtils.deleteQuietly(rendererdFile);
                }
            }
        };

        // Finally have PhantomJS create the preview
        logger.debug("Creating preview of {}", finalPageURL);
        phantomjs.execute();

    } catch (ProcessExcecutorException e) {
        logger.warn("Error creating page preview of {}: {}", pageURL, e.getMessage());
        throw new IOException(e);
    } finally {
        // If page preview rendering failed, there is no point in scaling the
        // images
        if (!success.get()) {
            logger.debug("Skipping scaling of failed preview rendering {}", pageURL);
            FileUtils.deleteQuietly(rendererdFile);
            return;
        }
    }

    FileInputStream imageIs = null;

    // Scale the image to the correct size
    try {
        imageIs = new FileInputStream(rendererdFile);
        imagePreviewGenerator.createPreview(resource, environment, language, style, PREVIEW_FORMAT, imageIs,
                os);
    } catch (IOException e) {
        logger.error("Error reading original page preview from " + rendererdFile, e);
        throw e;
    } catch (Throwable t) {
        logger.warn("Error scaling page preview at " + uri + ": " + t.getMessage(), t);
        throw new IOException(t);
    } finally {
        IOUtils.closeQuietly(imageIs);
        FileUtils.deleteQuietly(rendererdFile);
    }

}

From source file:com.datatorrent.stram.StramRecoveryTest.java

@Test
public void testRpcFailover() throws Exception {
    String appPath = testMeta.getPath();
    Configuration conf = new Configuration(false);
    final AtomicBoolean timedout = new AtomicBoolean();

    StreamingContainerUmbilicalProtocol impl = MockitoUtil
            .mockProtocol(StreamingContainerUmbilicalProtocol.class);

    Mockito.doAnswer(new org.mockito.stubbing.Answer<Void>() {
        @Override//ww w  . j a  va  2s .  co m
        public Void answer(InvocationOnMock invocation) {
            LOG.debug("got call: " + invocation.getMethod());
            if (!timedout.get()) {
                try {
                    timedout.set(true);
                    Thread.sleep(1000);
                } catch (Exception e) {
                }
                //throw new RuntimeException("fail");
            }
            return null;
        }
    }).when(impl).log("containerId", "timeout");

    Server server = new RPC.Builder(conf).setProtocol(StreamingContainerUmbilicalProtocol.class)
            .setInstance(impl).setBindAddress("0.0.0.0").setPort(0).setNumHandlers(1).setVerbose(false).build();
    server.start();
    InetSocketAddress address = NetUtils.getConnectAddress(server);
    LOG.info("Mock server listening at " + address);

    int rpcTimeoutMillis = 500;
    int retryDelayMillis = 100;
    int retryTimeoutMillis = 500;

    FSRecoveryHandler recoveryHandler = new FSRecoveryHandler(appPath, conf);
    URI uri = RecoverableRpcProxy.toConnectURI(address, rpcTimeoutMillis, retryDelayMillis, retryTimeoutMillis);
    recoveryHandler.writeConnectUri(uri.toString());

    RecoverableRpcProxy rp = new RecoverableRpcProxy(appPath, conf);
    StreamingContainerUmbilicalProtocol protocolProxy = rp.getProxy();
    protocolProxy.log("containerId", "msg");
    // simulate socket read timeout
    try {
        protocolProxy.log("containerId", "timeout");
        Assert.fail("expected socket timeout");
    } catch (java.net.SocketTimeoutException e) {
        // expected
    }
    Assert.assertTrue("timedout", timedout.get());
    rp.close();

    // test success on retry
    timedout.set(false);
    retryTimeoutMillis = 1500;
    uri = RecoverableRpcProxy.toConnectURI(address, rpcTimeoutMillis, retryDelayMillis, retryTimeoutMillis);
    recoveryHandler.writeConnectUri(uri.toString());

    protocolProxy.log("containerId", "timeout");
    Assert.assertTrue("timedout", timedout.get());

    rp.close();

    String rpcTimeout = System.getProperty(RecoverableRpcProxy.RPC_TIMEOUT);
    String rpcRetryDelay = System.getProperty(RecoverableRpcProxy.RETRY_DELAY);
    String rpcRetryTimeout = System.getProperty(RecoverableRpcProxy.RETRY_TIMEOUT);

    System.setProperty(RecoverableRpcProxy.RPC_TIMEOUT, Integer.toString(500));
    System.setProperty(RecoverableRpcProxy.RETRY_DELAY, Long.toString(100));
    System.setProperty(RecoverableRpcProxy.RETRY_TIMEOUT, Long.toString(500));

    timedout.set(false);
    uri = RecoverableRpcProxy.toConnectURI(address);
    recoveryHandler.writeConnectUri(uri.toString());

    rp = new RecoverableRpcProxy(appPath, conf);
    protocolProxy = rp.getProxy();
    protocolProxy.log("containerId", "msg");
    try {
        protocolProxy.log("containerId", "timeout");
        Assert.fail("expected socket timeout");
    } catch (java.net.SocketTimeoutException e) {
        // expected
    }
    Assert.assertTrue("timedout", timedout.get());
    rp.close();

    timedout.set(false);
    System.setProperty(RecoverableRpcProxy.RETRY_TIMEOUT, Long.toString(1500));

    uri = RecoverableRpcProxy.toConnectURI(address);
    recoveryHandler.writeConnectUri(uri.toString());

    protocolProxy.log("containerId", "timeout");
    Assert.assertTrue("timedout", timedout.get());

    restoreSystemProperty(RecoverableRpcProxy.RPC_TIMEOUT, rpcTimeout);
    restoreSystemProperty(RecoverableRpcProxy.RETRY_DELAY, rpcRetryDelay);
    restoreSystemProperty(RecoverableRpcProxy.RETRY_TIMEOUT, rpcRetryTimeout);

    server.stop();
}

From source file:io.druid.segment.realtime.plumber.RealtimePlumberSchoolTest.java

private void testPersist(final Object commitMetadata) throws Exception {
    final AtomicBoolean committed = new AtomicBoolean(false);
    plumber.getSinks().put(0L, new Sink(new Interval(0, TimeUnit.HOURS.toMillis(1)), schema, tuningConfig,
            new DateTime("2014-12-01T12:34:56.789").toString()));
    Assert.assertNull(plumber.startJob());

    final InputRow row = EasyMock.createNiceMock(InputRow.class);
    EasyMock.expect(row.getTimestampFromEpoch()).andReturn(0L);
    EasyMock.expect(row.getDimensions()).andReturn(new ArrayList<String>());
    EasyMock.replay(row);//from  w  w w  . j  a v  a  2 s .co m
    final Committer committer = new Committer() {
        @Override
        public Object getMetadata() {
            return commitMetadata;
        }

        @Override
        public void run() {
            committed.set(true);
        }
    };
    plumber.add(row, Suppliers.ofInstance(committer));
    plumber.persist(committer);

    while (!committed.get()) {
        Thread.sleep(100);
    }
    plumber.getSinks().clear();
    plumber.finishJob();
}

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

@Test
public void testMultipleThreads() 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/*  www .  jav  a2  s  . com*/
            public Map<Integer, Integer> call() throws Exception {

                barrier.await();

                TestWorker worker = new TestWorker();

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

                return worker.map;
            }
        }));
    }

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

    Map<Integer, Integer> totalMap = getTotalMap(futures);
    checkValues(new ArrayList<Integer>(totalMap.values()));
}

From source file:ch.cyberduck.core.cryptomator.impl.CryptoVaultTest.java

@Test
public void testLoadInvalidPassphrase() throws Exception {
    final NullSession session = new NullSession(new Host(new TestProtocol())) {
        @Override// ww  w  .  j  ava2 s.  c o m
        @SuppressWarnings("unchecked")
        public <T> T _getFeature(final Class<T> type) {
            if (type == Read.class) {
                return (T) new Read() {
                    @Override
                    public InputStream read(final Path file, final TransferStatus status,
                            final ConnectionCallback callback) throws BackgroundException {
                        final String masterKey = "{\n" + "  \"scryptSalt\": \"NrC7QGG/ouc=\",\n"
                                + "  \"scryptCostParam\": 16384,\n" + "  \"scryptBlockSize\": 8,\n"
                                + "  \"primaryMasterKey\": \"Q7pGo1l0jmZssoQh9rXFPKJE9NIXvPbL+HcnVSR9CHdkeR8AwgFtcw==\",\n"
                                + "  \"hmacMasterKey\": \"xzBqT4/7uEcQbhHFLC0YmMy4ykVKbuvJEA46p1Xm25mJNuTc20nCbw==\",\n"
                                + "  \"versionMac\": \"hlNr3dz/CmuVajhaiGyCem9lcVIUjDfSMLhjppcXOrM=\",\n"
                                + "  \"version\": 5\n" + "}";
                        return IOUtils.toInputStream(masterKey, Charset.defaultCharset());
                    }

                    @Override
                    public boolean offset(final Path file) throws BackgroundException {
                        return false;
                    }
                };
            }
            return super._getFeature(type);
        }
    };
    final AtomicBoolean prompt = new AtomicBoolean();
    final CryptoVault vault = new CryptoVault(new Path("/", EnumSet.of(Path.Type.directory)),
            new DisabledPasswordStore());
    try {
        vault.load(session, new DisabledPasswordCallback() {
            @Override
            public Credentials prompt(final Host bookmark, final String title, final String reason,
                    final LoginOptions options) throws LoginCanceledException {
                if (!prompt.get()) {
                    assertEquals("Provide your passphrase to unlock the Cryptomator Vault /", reason);
                    prompt.set(true);
                    return new VaultCredentials("null");
                } else {
                    assertEquals(
                            "Failure to decrypt master key file. Provide your passphrase to unlock the Cryptomator Vault /.",
                            reason);
                    throw new LoginCanceledException();
                }
            }
        });
        fail();
    } catch (LoginCanceledException e) {
        //
    }
    assertTrue(prompt.get());
}

From source file:io.druid.segment.realtime.plumber.RealtimePlumberSchoolTest.java

private void testPersistHydrantGapsHelper(final Object commitMetadata) throws Exception {
    final AtomicBoolean committed = new AtomicBoolean(false);
    Interval testInterval = new Interval(new DateTime("1970-01-01"), new DateTime("1971-01-01"));

    RealtimePlumber plumber2 = (RealtimePlumber) realtimePlumberSchool.findPlumber(schema2, tuningConfig,
            metrics);//from   w ww  .  j  a  va  2  s.  com
    plumber2.getSinks().put(0L,
            new Sink(testInterval, schema2, tuningConfig, new DateTime("2014-12-01T12:34:56.789").toString()));
    Assert.assertNull(plumber2.startJob());

    final Committer committer = new Committer() {
        @Override
        public Object getMetadata() {
            return commitMetadata;
        }

        @Override
        public void run() {
            committed.set(true);
        }
    };
    plumber2.add(getTestInputRow("1970-01-01"), Suppliers.ofInstance(committer));
    plumber2.add(getTestInputRow("1970-02-01"), Suppliers.ofInstance(committer));
    plumber2.add(getTestInputRow("1970-03-01"), Suppliers.ofInstance(committer));
    plumber2.add(getTestInputRow("1970-04-01"), Suppliers.ofInstance(committer));
    plumber2.add(getTestInputRow("1970-05-01"), Suppliers.ofInstance(committer));

    plumber2.persist(committer);

    while (!committed.get()) {
        Thread.sleep(100);
    }
    plumber2.getSinks().clear();
    plumber2.finishJob();

    File persistDir = plumber2.computePersistDir(schema2, testInterval);

    /* Check that all hydrants were persisted */
    for (int i = 0; i < 5; i++) {
        Assert.assertTrue(new File(persistDir, String.valueOf(i)).exists());
    }

    /* Create some gaps in the persisted hydrants and reload */
    FileUtils.deleteDirectory(new File(persistDir, "1"));
    FileUtils.deleteDirectory(new File(persistDir, "3"));
    RealtimePlumber restoredPlumber = (RealtimePlumber) realtimePlumberSchool.findPlumber(schema2, tuningConfig,
            metrics);
    restoredPlumber.bootstrapSinksFromDisk();

    Map<Long, Sink> sinks = restoredPlumber.getSinks();
    Assert.assertEquals(1, sinks.size());

    List<FireHydrant> hydrants = Lists.newArrayList(sinks.get(new Long(0)));
    DateTime startTime = new DateTime("1970-01-01T00:00:00.000Z");
    Assert.assertEquals(0, hydrants.get(0).getCount());
    Assert.assertEquals(new Interval(startTime, new DateTime("1970-01-01T00:00:00.001Z")),
            hydrants.get(0).getSegment().getDataInterval());
    Assert.assertEquals(2, hydrants.get(1).getCount());
    Assert.assertEquals(new Interval(startTime, new DateTime("1970-03-01T00:00:00.001Z")),
            hydrants.get(1).getSegment().getDataInterval());
    Assert.assertEquals(4, hydrants.get(2).getCount());
    Assert.assertEquals(new Interval(startTime, new DateTime("1970-05-01T00:00:00.001Z")),
            hydrants.get(2).getSegment().getDataInterval());

    /* Delete all the hydrants and reload, no sink should be created */
    FileUtils.deleteDirectory(new File(persistDir, "0"));
    FileUtils.deleteDirectory(new File(persistDir, "2"));
    FileUtils.deleteDirectory(new File(persistDir, "4"));
    RealtimePlumber restoredPlumber2 = (RealtimePlumber) realtimePlumberSchool.findPlumber(schema2,
            tuningConfig, metrics);
    restoredPlumber2.bootstrapSinksFromDisk();

    Assert.assertEquals(0, restoredPlumber2.getSinks().size());
}

From source file:org.springsource.ide.eclipse.commons.internal.configurator.ConfiguratorImporter.java

public List<ConfigurableExtension> detectExtensions(final IProgressMonitor monitor) {
    final List<ConfigurableExtension> result = new ArrayList<ConfigurableExtension>();
    Set<WorkspaceConfiguratorParticipant> participants = ParticipantExtensionPointReader.getParticipants();
    for (final WorkspaceConfiguratorParticipant participant : participants) {
        SafeRunner.run(new ISafeRunnable() {
            public void handleException(Throwable exception) {
                // logged by super class
            }//  w w  w. j ava2 s.c  o  m

            public void run() throws Exception {
                List<ConfigurableExtension> extensions = participant.detectExtensions(ConfiguratorImporter.this,
                        monitor);
                result.addAll(extensions);
            }
        });
    }
    Set<InstallableItem> installableItems = ParticipantExtensionPointReader.getInstallableItems();
    for (final InstallableItem item : installableItems) {
        boolean found = false;
        for (ConfigurableExtension extension : result) {
            if (extension.getId().equals(item.getId())) {
                extension.setInstallableItem(item);
                found = true;
            }
        }
        if (!found) {
            for (final WorkspaceConfiguratorParticipant participant : participants) {
                if (participant.getId().equals(item.getConfiguratorId())) {
                    final AtomicBoolean added = new AtomicBoolean(false);
                    SafeRunner.run(new ISafeRunnable() {
                        public void handleException(Throwable exception) {
                            // logged by super class
                        }

                        public void run() throws Exception {
                            ConfigurableExtension extension = participant.createExtension(item, monitor);
                            if (extension != null) {
                                result.add(extension);
                                added.set(true);
                            }
                        }
                    });
                    if (added.get()) {
                        break;
                    }
                }
            }
        }
    }

    return result;
}