标签: synchronization

我正在寻找Windows Azure上虚拟机之间时钟偏移的定量估计- 假设所有虚拟机都托管在同一个数据中心.我猜测一个VM和另一个VM之间的平均时钟偏移低于10秒,但我甚至不确定它是Azure云的保证属性.

有没有人对此事进行定量测量？

我必须将N个客户端进程与一个服务器同步.这些进程由一个main函数分叉,我在其中声明了3个信号量.我决定使用POSIX信号量,但我不知道如何在这些进程之间共享它们.我认为共享内存应该正常工作,但我有一些问题:

• 如何在我的片段中分配正确的内存空间？
• 我可以sizeof(sem_t)在size_t字段中shmget使用以便准确分配我需要的空间吗？
• 有没有人有类似这种情况的例子？

我有两个线程Thread1和Thread2

//Within Thread1     
synchronized(obj1)  
{  
    obj1 = null;  
}  

//Within Thread2  
synchronized(obj1)  
{  
    do something  
}   

如果jvm首先执行thread1并将obj1设置为null,那么thread2会立即看到该更改还是需要时间并且jvm仍然可以运行thread2 synchronized块,因为obj1还不是null？

在不锁定整个集合的情况下,防止在键值集中并发更新一个记录的最佳方法是什么？从语义上讲,我正在寻找某种键的锁定(理想情况下,Java实现,但不一定):

interface LockByKey {
   void lock(String key); // acquire an exclusive lock for a key   
   void unlock(String key); // release lock for a key
}

此锁用于同步对远程存储的访问,因此某些同步Java集合不是一个选项.

我有一类线程安全的公共代码.

该类中的一个方法是抽象的,需要为不同的实现重写.

我需要确保或至少向其他开发人员标记此方法的所有实现都需要是线程安全的.

做这个的最好方式是什么？

这个效果有关键字或注释吗？

我已经尝试过,abstract synchronized但不允许使用关键字组合.

可能重复:
.class的Java同步块

我正在阅读有关同步的文章.我对以下几点感到困惑,需要进一步澄清

1)用于同步块.怎么样

   synchronize(this){
    // code
   }

不同于

   synchronize(MyClass.class){
    //code
   }

2)同步实例方法意味着线程必须获得对实例的独占锁定,而同步静态方法意味着线程必须获取整个类的锁定(如果我错了,请纠正我).因此,如果一个类有三个方法,其中一个是静态同步的,那么如果一个线程获得该方法的锁定,那么这意味着它将获得对整个类的锁定.那么这是否意味着其他两个也将被锁定,没有其他方法可以访问这两个方法,因为整个类都有锁定？

我在项目中面对以下代码:

synchronized (Thread.currentThread()){
    //some code
}

我不明白使用synchronized的原因currentThread.

两者之间有什么区别吗？

synchronized (Thread.currentThread()){
    //some code
}

只是

//some code

你能提供一个显示差异的例子吗？

UPDATE

更详细的代码如下:

synchronized (Thread.currentThread()) {
       Thread.currentThread().wait(timeInterval);
}

看起来就像Thread.sleep(timeInterval).这是真的吗？

我正在NSManagedObjectContext私有队列中创建一个处理来自文件和/或服务的数据更新:

NSManagedObjectContext *privateContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
AppDelegate *appDelegate = [[UIApplication sharedApplication] delegate];
privateContext.persistentStoreCoordinator = appDelegate.persistentStoreCoordinator;

由于我使用的是私有队列,我不完全理解performBlock:和performBlockAndWait:方法之间的区别......为了执行我的数据更新,我目前正在这样做:

[privateContext performBlock: ^{

        // Parse files and/or call services and parse
        // their responses

        // Save context
        [privateContext save:nil];

        dispatch_async(dispatch_get_main_queue(), ^{
            // Notify update to user
        });
    }];

在这种情况下,我的数据更新是同步和顺序进行的,所以我认为这是保存上下文的正确位置,对吧？如果我做错了什么,如果你告诉我,我会很感激.另一方面,这段代码是否相同？:

[privateContext performBlockAndWait: ^{

        // Parse files and/or call services and parse
        // their responses

        // Save context
        [privateContext save:nil];
    }];

// Notify update to user

我想这是保存上下文的正确位置......这两种方法之间有什么区别(如果有的话,在这种情况下)？

如果不是执行同步服务调用或文件解析,我需要执行异步服务调用怎么办？如何管理这些数据更新？

提前致谢

虽然我熟悉并发编程概念,如互斥和信号量,但我从未理解它们是如何在汇编语言级别实现的.

我想有一组内存"标志"说:

• 锁A由线程1保持
• 锁B由螺纹3保持
• 锁C不被任何线程保持
• 等等

但是如何在线程之间同步访问这些标志呢？像这个天真的例子只会产生竞争条件:

  mov edx, [myThreadId]
wait:
  cmp [lock], 0
  jne wait
  mov [lock], edx
  ; I wanted an exclusive lock but the above 
  ; three instructions are not an atomic operation :(

这是一个面试问题.

是否可以在Linux/UNIX上的多处理案例中使用互斥？

我的想法:不,不同的进程有独立的内存空间.

mutex仅用于多线程.

信号量用于多处理以进行同步.

对 ？

欢迎任何评论.

谢谢