download zip of files only
Sat Mar 19 12:00:19 GMT 2022
From /weblog/java/concurrency
Just know that interrupt() call is just setting a flag, it have to be doing IO work (like database call), or in wait() status, before the thread can really be interrupted. http://blogs.sun.com[..]winger?entry=swingworker_stop_that_train Another nice explanation about interrupt, in summary: What should we do when we call code that may cause an InterruptedException? Don't immediately yank out the batteries! Typically there are two answers to that question: 1) Rethrow the InterruptedException from your method. This is usually the easiest and best approach. It is used by the new java.util.concurrent.* package [ http://java.sun.com[..]util/concurrent/Semaphore.html#acquire() ], which explains why we are now constantly coming into contact with this exception. 2) Catch it, set interrupted status, return. If you are running in a loop that calls code which may cause the exception, you should set the status back to being interrupted. For example: while (!Thread.currentThread().isInterrupted()) {
// do something
try {
TimeUnit.SECONDS.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}Remember the Law of the Sabotaged Doorbell - don't just ignore interruptions, manage them properly! - http://www.javaspecialists.eu/archive/Issue146.html Another blog explain about InterruptedException - http://www.nurkiewicz.com[..]terruptedexception-and-interrupting.html http://ocpsoft.org[..]running-infinite-java-regular-expression http://praveer09.github.io[..]derstanding-thread-interruption-in-java/ How to Stop a Java Thread Without Using Thread.stop()? - https://4comprehension.com[..]a-java-thread-without-using-thread-stop/
(google search)
(amazon search)
Sun Mar 29 10:15:44 GMT 2020
From /weblog/java/concurrency
Even though
private List synchList = Collections.synchronizedList(new LinkedList());
is thread safe, serialize sync List is NOT thread safe for sure. The story is, if you only synchronized the collection, and if we try to get the iterator in concurrent access environment, it will throws currencymodificationexception . For collection is small, may be making defensive copy http://www.javapractices.com/Topic15.cjp is good. Otherwise, in java5, there is concurrency collection. reference: http://jroller.com[..]ntry=collections_synchronizedlist_broken http://jroller.com/page/ctarrington?entry=java_collections_trivia Map operation, include use of FutureTask and putIfAbsent() method from ConcurrentMap. - http://www.javaspecialists.co.za/archive/newsletter.do?issue=125 Other then lterate through the elements, adding and removing elements can also be problem, this article document a few good cases about that - http://rayfd.wordpress.com[..]en-a-synchronized-class-isnt-threadsafe/ Samples of using Queue.drainTo() - http://binkley.blogspot.com[..]rforming-fixed-amounts-of-work-with.html http://tech.puredanger.com/2009/02/28/java-7-transferqueue/ Overview of blockingqueue - http://tutorials.jenkov.com[..]/java-util-concurrent/blockingqueue.html Simple benchmark - http://java-persistence-performance.blogspot.com[..]jvm-performance-part-iii-concurrent.html Multi-thread behaviour - http://vanillajava.blogspot.com[..]hread-safety-issues-with-vector-and.html java.util.concurrent.ConcurrentHashMap VS openhft.collections.SharedHashMap - http://openhft.blogspot.co.uk[..]autilconcurrentconcurrenthashmap-vs.html Why are there so many concurrent queues implementations in Java? - https://vmlens.com/articles/cp/why_so_many_queues/ Why hashmap is not thread safe - https://www.pixelstech.net[..]a-HashMap-is-considered-as-thread-unsafe
(google search)
(amazon search)
Fri Mar 10 09:49:16 GMT 2017
From /weblog/java/concurrency
putall can cause ConcurrentModifcationException - http://cr.openjdk.java.net[..]ses/sun/management/Agent.java.sdiff.html Note on writing CopyOnWrite wrapper - http://flyingspaniel.blogspot.com[..]ot.com/2010/12/copyonwrite-wrappers.html Sometime this is a bit difficult for Chinese to be a good programmer, recently some colleague and me discuss about the behaviour of this class and look like we have difficult understanding A: ConcurrentHashMap support for locking as this is thread-safe B: ConcurrentHashMap is thread safe for read but not for write because there is no lock, we still need to have external lock to keep it thread safe. By the way, I get ConcurrentModificationException from this before. C: ConcurrentHashMap don't support for locking but they still thread safe for all operations, which is how "This class is fully interoperable with Hashtable in programs that rely on its thread safety but not on its synchronization details." mentioned. Too good that we can actually take a look at the source code to see what going on nowadays rather than just guessing - http://www.google.com[..]HashMap&sourceid=opera&ie=utf-8&oe=utf-8 By the way, this constructor is useful for a lot of concurrency access but actually not many developer notice about this - http://java.sun.com[..]rrentHashMap.html#ConcurrentHashMap(int, float, int) Lazy initialization of map values - http://artisans-serverintellect-com.si-eioswww6.com[..]ect-com.si-eioswww6.com/default.asp?W122 HashMap.get() can cause infinite loop - http://lightbody.net[..]5/07/hashmapget_can_cause_an_infini.html Discussing the effect of initCapacity() of HashMap in Java - http://saloon.javaranch.com[..]ltimatebb.cgi?ubb=get_topic&f=1&t=021171 OpenJDK and HashMap …. Safely Teaching an Old Dog New (Off-Heap!) Tricks - http://www.infoq.com/articles/Open-JDK-and-HashMap-Off-Heap We can run search in ConcurrenctHashMap - https://dzone.com/articles/concurrenthashmap-in-java8
(google search)
(amazon search)
Sun Aug 28 11:58:48 GMT 2011
From /weblog/java/concurrency
Sample code of try-sync
import sun.misc.*;
import java.lang.reflect.*;
public class MonitorUtils {
private static Unsafe unsafe = getUnsafe();
public static boolean trySynchronize(Object monitor) {
return unsafe.tryMonitorEnter(monitor);
}
public static void unsynchronize(Object monitor) {
unsafe.monitorExit(monitor);
}
private static Unsafe getUnsafe() {
try {
for (Field field : Unsafe.class.getDeclaredFields()) {
if (Modifier.isStatic(field.getModifiers())) {
if (field.getType() == Unsafe.class) {
field.setAccessible(true);
return (Unsafe) field.get(null);
}
}
}
throw new IllegalStateException("Unsafe field not found");
} catch (Exception e) {
throw new IllegalStateException(
"Could not initialize unsafe", e);
}
}
}
http://www.javaspecialists.eu/archive/Issue194.html
(google search)
(amazon search)
Tue Feb 15 17:16:05 GMT 2011
From /weblog/java/concurrency
Here is an tricky concurrency concern in Java when using Anonymous Inner Class with ExecutorService, if you use collection from outside class, that collection actually a global variable in the Inner Class, and need to take care the issues happened in concurrency access. For this class:
public static void main(String[] args) throws InterruptedException {
ExecutorService es = Executors.newFixedThreadPool(80);
final List list = new ArrayList();
for (int i = 0; i < 100000; i++)
es.execute(new Runnable() {
@Override
public void run() {
list.add(new String());
}
});
es.shutdown();
while (true) {
boolean terminated = es.awaitTermination(5, TimeUnit.SECONDS);
if (terminated) {
break;
}
}
for (String string : list) {
if (string == null)
System.out.println("Have null");
}
}
actually same as
private static final class RunnableImpl implements Runnable {
private final List mList;
private RunnableImpl(List list) {
mList = list;
}
@Override
public void run() {
mList.add(new String());
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService es = Executors.newFixedThreadPool(80);
final List list = new ArrayList();
for (int i = 0; i < 100000; i++)
es.execute(new RunnableImpl(list));
/** @formatter:on */
es.shutdown();
while (true) {
boolean terminated = es.awaitTermination(5, TimeUnit.SECONDS);
if (terminated) {
break;
}
}
for (String string : list) {
if (string == null)
System.out.println("Have null");
}
}
(google search)
(amazon search)
|