Guava’s CacheBuilder class allows you to do this easily. CacheBuilder.newBuilder().weakKeys().build() Note that this changes key equality semantics to be == instead of .equals() which will not matter in your case of using Class instances but is a potential pitfall.
The get() method is thread-safe, and the other users gave you useful answers regarding this particular issue. However, although ConcurrentHashMap is a thread-safe drop-in replacement for HashMap, it is important to realize that if you are doing multiple operations you may have to change your code significantly. For example, take this code: if (!map.containsKey(key)) return … Read more
Since no answer to the actual question has been given, here’s my personal opinion based on the other answers (thanks, upvoted) and Java convention: incrementAndGet() is better, because method names should start with the verb describing the action, and intended action here is to increment only. Starting with verb is the common Java convention, also … Read more
In summary, you can think of it that way: shutdown() will just tell the executor service that it can’t accept new tasks, but the already submitted tasks continue to run shutdownNow() will do the same AND will try to cancel the already submitted tasks by interrupting the relevant threads. Note that if your tasks ignore … Read more
Read up on streams, they’re all the new rage. Pay especially close attention to the bit about parallelism: “Processing elements with an explicit for-loop is inherently serial. Streams facilitate parallel execution by reframing the computation as a pipeline of aggregate operations, rather than as imperative operations on each individual element. All streams operations can execute … Read more
unsafe.park is pretty much the same as thread.wait, except that it’s using architecture specific code (thus the reason it’s ‘unsafe’). unsafe is not made available publicly, but is used within java internal libraries where architecture specific code would offer significant optimization benefits. It’s used a lot for thread pooling. So, to answer your question, all … Read more
A CachedThreadPool seems appropriate for your situation as there are no negative consequence to using one for long running threads directly. The comment in the java doc about CachedThreadPools being suitable for short tasks merely suggest that they are particularly appropriate for such cases, not that they cannot be used for long running tasks. The … Read more
The Oracle’s implementation[1] of parallel stream uses the current thread and in addition to that, if needed, also the threads that compose the default fork join pool ForkJoinPool.commonPool(), which has a default size equal to one less than the number of cores of your CPU. That default size of the common pool can be changed … Read more
Any object in Java can be used as a lock using a synchronized block. This will also automatically take care of releasing the lock when an exception occurs. Object someObject = …; synchronized (someObject) { … } You can read more about this here: Intrinsic Locks and Synchronization
If you’re simply locking an object, I’d prefer to use synchronized Example: Lock.acquire(); doSomethingNifty(); // Throws a NPE! Lock.release(); // Oh noes, we never release the lock! You have to explicitly do try{} finally{} everywhere. Whereas with synchronized, it’s super clear and impossible to get wrong: synchronized(myObject) { doSomethingNifty(); } That said, Locks may be … Read more