public ThreadLocal<BackendModel> getModel() { if(null == _model) { _model = new ThreadLocal<>(); } return _model; }
class StaticClass { static private ThreadLocal threadLocal = new ThreadLocal<User>(); static ThreadLocal<User> getThreadLocal() { return threadLocal; } }
private ThreadLocal<StringMap> createThreadLocalMap() { if (inheritableMap) { return new InheritableThreadLocal<StringMap>() { @Override protected StringMap childValue(final StringMap parentValue) { return parentValue != null ? createStringMap(parentValue) : null; } }; } // if not inheritable, return plain ThreadLocal with null as initial value return new ThreadLocal<>(); }
public ThriftCLIService(CLIService service, String serviceName) { super(serviceName); this.cliService = service; currentServerContext = new ThreadLocal<ServerContext>(); }
/** * @param async Async enabled flag. */ public AsyncSupportAdapter(boolean async) { if (async) curFut = new ThreadLocal<>(); }
/** * Construct a new instance. */ protected PeerIdentityContext() { currentIdentity = new ThreadLocal<>(); }
InjectorImpl(InjectorImpl parent, State state, InjectorOptions injectorOptions) { this.parent = parent; this.state = state; this.options = injectorOptions; if (parent != null) { localContext = parent.localContext; } else { // No ThreadLocal.initialValue(), as that would cause classloader leaks. See // https://github.com/google/guice/issues/288#issuecomment-48216933, // https://github.com/google/guice/issues/288#issuecomment-48216944 localContext = new ThreadLocal<>(); } }
ThreadLocalTransaction(RuntimeConfiguration configuration) { this.threadLocal = new ThreadLocal<>(); this.configuration = configuration; }
public abstract class BeforeFilter implements SerializeFilter { private static final ThreadLocal<JSONSerializer> serializerLocal = new ThreadLocal<JSONSerializer>(); private static final ThreadLocal<Character> seperatorLocal = new ThreadLocal<Character>(); private final static Character COMMA = Character.valueOf(','); final char writeBefore(JSONSerializer serializer, Object object, char seperator) { serializerLocal.set(serializer); seperatorLocal.set(seperator); writeBefore(object); serializerLocal.set(null); return seperatorLocal.get(); } protected final void writeKeyValue(String key, Object value) { JSONSerializer serializer = serializerLocal.get(); char seperator = seperatorLocal.get(); serializer.writeKeyValue(seperator, key, value); if (seperator != ',') { seperatorLocal.set(COMMA); } } public abstract void writeBefore(Object object); }
/** * @since 1.1.35 */ public abstract class AfterFilter implements SerializeFilter { private static final ThreadLocal<JSONSerializer> serializerLocal = new ThreadLocal<JSONSerializer>(); private static final ThreadLocal<Character> seperatorLocal = new ThreadLocal<Character>(); private final static Character COMMA = Character.valueOf(','); final char writeAfter(JSONSerializer serializer, Object object, char seperator) { serializerLocal.set(serializer); seperatorLocal.set(seperator); writeAfter(object); serializerLocal.set(null); return seperatorLocal.get(); } protected final void writeKeyValue(String key, Object value) { JSONSerializer serializer = serializerLocal.get(); char seperator = seperatorLocal.get(); serializer.writeKeyValue(seperator, key, value); if (seperator != ',') { seperatorLocal.set(COMMA); } } public abstract void writeAfter(Object object); }
public JobContextImpl(JavaSparkContext sc, File localTmpDir) { this.sc = sc; this.monitorCb = new ThreadLocal<MonitorCallback>(); monitoredJobs = new ConcurrentHashMap<String, List<JavaFutureAction<?>>>(); addedJars = new ConcurrentHashMap<>(); this.localTmpDir = localTmpDir; }
@Resetter public static void reset() { // sAnimationHelper is a static field used for processing delayed animations. Since it registers // callbacks on the Choreographer, this is a problem if not reset between tests (as once the // test is complete, its scheduled callbacks would be removed, but the static object would still // believe it was registered and not re-register for the next test). ReflectionHelpers.setStaticField( RenderNodeAnimator.class, "sAnimationHelper", new ThreadLocal<>()); }
@Resetter public static void reset() { _ViewRootImpl_ _viewRootImplStatic_ = reflector(_ViewRootImpl_.class); _viewRootImplStatic_.setRunQueues(new ThreadLocal<>()); _viewRootImplStatic_.setFirstDrawHandlers(new ArrayList<>()); _viewRootImplStatic_.setFirstDrawComplete(false); _viewRootImplStatic_.setConfigCallbacks(new ArrayList<>()); }
@Test public void testTimeoutStreamEndCallbackAsynchronously() { TimeoutStream stream = vertx.timerStream(200); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v2 -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); stream.handler(id -> { }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously2() { MessageConsumer<Object> consumer = eb.consumer(ADDRESS1); consumer.handler(msg -> { }); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously() { MessageConsumer<Object> consumer = eb.consumer(ADDRESS1); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); consumer.handler(msg -> { }); await(); }
@Test public void testEndHandler() { ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); peer2 = vertx.createDatagramSocket(new DatagramSocketOptions()); peer2.listen(1234, "127.0.0.1", ar -> { assertTrue(ar.succeeded()); peer2.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); peer2.close(); }); await(); }
@Test public void testAsyncFileCloseHandlerIsAsync() throws Exception { String fileName = "some-file.dat"; createFileWithJunk(fileName, 100); AsyncFile file = vertx.fileSystem().openBlocking(testDir + pathSep + fileName, new OpenOptions()); ThreadLocal stack = new ThreadLocal(); stack.set(true); file.close(ar -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); testComplete(); }); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously1() { startNodes(2); MessageConsumer<Object> consumer = vertices[0].eventBus().consumer(ADDRESS1); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); consumer.handler(msg -> {}); await(); }
@Test public void testConsumerHandlesCompletionAsynchronously2() { startNodes(2); MessageConsumer<Object> consumer = vertices[0].eventBus().consumer(ADDRESS1); consumer.handler(msg -> { }); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); consumer.completionHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); testComplete(); }); await(); }