Here’s my attempt at answering my own question. I think that the following conditions should be sufficient for a single thread to be safely stopped using Thread.stop(): The thread execution must not create or mutate any state (i.e. Java objects, class variables, external resources) that might be visible to other threads in the event that … Read more
You should really check out this article: http://brooker.co.za/blog/2012/09/10/volatile.html. The blog article argues volatile reads can be a lot slower (also for x86) than non-volatile reads on x86. Test 1 is a parallel read and write to a non-volatile variable. There is no visibility mechanism and the results of the reads are potentially stale. Test 2 … Read more
b = !b is not atomic because in the C++ source you have an atomic pure read of b (equivalent to b.load(), and then a separately-atomic assignment to b (equivalent to b.store()). Nothing makes the entire combination into an atomic RMW operation in the C++ abstract machine, and there’s no syntax for composing arbitrary operations … Read more
If I understand your problem, one way would be to adaptively sleep the threads, similarly as video playback is done in Java. If you know you want 50% core utilization, the your algorithm should sleep approximately 0.5 seconds – potentially distributed within a second (e.g. 0.25 sec computation, 0.25 sec sleep, e.t.c.). Here is an … Read more
I like the question too. It forced me to dig into Android source code once again. I believe this works because post() gets called after setContentView(). Method setContentView() ends up in calling ViewGroup.addView() of the top view, and addView() call always triggers requestLayout(). In turn, requestLayout() posts a task to the main thread to be … Read more
In database management theory, locking is used to implement isolation among multiple database users txn. This is the “I” in the acronym ACID (Atomicity, Consistency, Isolation, Durability). Locks are applied by a TX (transaction) to data, which may block other TXs from accessing the same data during the TX’s life. Simple Locking: Two main types … Read more
Firstly, threading is tricky ;-p Yes, despite all the rumours to the contrary, it is required to either use lock or volatile (but not both) when accessing a bool from multiple threads. For simple types and access such as an exit flag (bool), then volatile is sufficient – this ensures that threads don’t cache the … Read more
The C++11 standard guarantees that const method access to containers is safe from different threads (ie, both use const methods). In addition, [container.requirements.dataraces] states implementations are required to avoid data races when the contents of the contained object in different elements in the same sequence, excepting vector<bool> In other words, except for vector<bool> modifying distinct … Read more
You have to join std::threads, just like you have to join pthreads. int main( int argc, char *argv[] ) { std::thread t( doSomeWork ); t.join(); return 0; } UPDATE: This Debian bug report pointed me to the solution: add -pthread to your commandline. This is most probably a workaround until the std::thread code stabilizes and … Read more
Each Thread will be given a native OS Thread to RUN which can run on a different CPU but since Java is interpreted these threads will require to interact with the JVM again and again to convert the byte code to machine instructions ? Am I right ? You are mixing two different things; JIT … Read more