synchronization

I was thinking of using multiple Android devices (e.g. Nexus 7 tablets) to build a photo / video wall and I'm wondering a) whether it is possible and b) how to synchronize the display of all these devices. Google showed off its Chrome racer experiment so clearly it is possible to synchronize displays across many devices. So here are my questions: what technology should I use to synchronize the displays? Android? Chrome? Please point me to existing code if possible. what's the minimum lag between devices that could be achieved in such a setup? can video and sound playback also be started

I realize that I really need to rewrite my programs data structure (not now, but soon, as the deadline is monday), as I am currently using VST (VirtualStringTree) to store my data. What I would like to achieve, is a Contact List structure. The Rootnodes are the Categories, and the children are the Contacts. There is a total of 2 levels. The thing is though, that I need a contact to display in more than 1 category, but they need to be synchronized. Particularly the Checkstate . Currently, to maintain sync, I loop thru my whole tree to find nodes that have the same ID as the one that was just

When using something like this: private final Object lock = new Object() Is there any difference between static and non-static one? Can non-static object lock static method or vice versa? If you're using a non-static lock, every instance of the object would have a different lock object, and it would be a potentially more fine grained equivalent of calling: synchronized(this) { } That is to say: you're only locking against other accesses from within the same object. With a static lock, every instance of the class shares that lock object. So only one thread can access the synchronized block at

I have just written my own logging framework (very lightweight, no need for a big logging framework). It consists of an interface ILogger and a number of classes implementing that interface. The one I have a question about is TGUILogger which takes a TStrings as the logging target and synchronizes the logging with the main thread so that the Items member of a listbox can be used as the target. type ILogger = Interface (IInterface) procedure Log (const LogString : String; LogLevel : TLogLevel); procedure SetLoggingLevel (LogLevel : TLogLevel); end; type TGUILogger = class (TInterfacedObject,

I have a service that runs in the background which can access (read and write) to sqlite database. The corresponding foreground process (main app) can also access (read and write) to sqlite database in my android application. How can i prevent problems related to trying to access / save / read at the same time to/from sqlite db and what should be the correct way to do this? There are 2 easy ways to do this, the first as ChirstopheCVB writes: Create a synchronized method. A synchronized method can only be accessed by one thread, other threads are blocked. This is the recommended method, as it

Suppose I have a Utility class, public class Utility { private Utility() {} //Don't worry, just doing this as guarantee. public static int stringToInt(String s) { return Integer.parseInt(s); } }; Now, suppose, in a multithreaded application, a thread calls, Utility.stringToInt() method and while the operation enters the method call, another thread calls the same method passing a different s . What happens in this case? Does Java lock a static method? There is no issue here. Each thread will use its own stack so there is no point of collision among different s . And Integer.parseInt() is thread

We started some overseas merge replication 1 year ago and everything is going fine till now. My problem is that we have now so much data in our system that any crash on one of the subscriber's servers will be a disaster: reinitialising a subscription the standard way will take days (our connexions are definitely slow, but already very very expensive)! Among the ideas I have been following up are the following: make a copy of the original database, freeze it, send the files by plane to the subscriber, and initiate replication without snapshot: this is something that was done traditionnaly with

While I was taking a look on the golang memory model document( link ), I found a weird behavior on go lang. This document says that below code can happen that g prints 2 and then 0. var a, b int func f() { a = 1 b = 2 } func g() { print(b) print(a) } func main() { go f() g() } Is this only go routine issue? Because I am curious that why value assignment of variable 'b' can happen before that of 'a'? Even if value assignment of 'a' and 'b would happen in different thread(not in main thread), does it have to be ensured that 'a' should be assigned before 'b' in it's own thread?(because assignment