标签: synchronization

我看到,对于使用非线程安全的对象,我们用这样的锁包装代码:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

那么当多个线程访问相同的代码时会发生什么(让我们假设它在ASP.NET Web应用程序中运行).他们排队了吗？如果是这样,他们会等多久？

使用锁会对性能产生什么影响？

每当有关Java同步的问题出现时,有些人非常渴望指出synchronized(this)应该避免的.相反,他们声称,首选锁定私人参考.

一些给出的原因是:

• 一些邪恶的代码可能会偷你的锁(这个非常受欢迎,也有一个"意外"变种)
• 同一类中的所有同步方法使用完全相同的锁,这会降低吞吐量
• 你(不必要地)暴露了太多的信息

其他人,包括我在内,认为这synchronized(this)是一个被大量使用的习惯用法(也在Java库中),是安全且易于理解的.它不应该被避免,因为你有一个错误,你不知道多线程程序中发生了什么.换句话说:如果适用,则使用它.

我有兴趣看到一些现实世界的例子(没有foobar的东西)避免锁定this是最好的,当synchronized(this)也做的工作.

因此:您是否应始终避免synchronized(this)并使用私有引用上的锁来替换它？

一些进一步的信息(更新为答案):

• 我们正在谈论实例同步
• 考虑隐式(synchronized方法)和显式形式synchronized(this)
• 如果您引用Bloch或其他有关该主题的权限,请不要遗漏您不喜欢的部分(例如,有效Java,线程安全项目:通常它是实例本身的锁,但也有例外.)
• 如果你需要锁定的粒度而不是synchronized(this)提供,那么synchronized(this)不适用,所以这不是问题

c#是否有自己的java"synchronized"关键字版本？

即在java中,它可以指定为函数,对象或代码块,如下所示:

public synchronized void doImportantStuff() {
   // dangerous code goes here.
}

要么

public void doImportantStuff() {
   // trivial stuff

   synchronized(someLock) {
      // dangerous code goes here.
   }
}

原子/易失性/同步如何在内部工作？

以下代码块之间有什么区别？

代码1

private int counter;

public int getNextUniqueIndex() {
    return counter++; 
}

代码2

private AtomicInteger counter;

public int getNextUniqueIndex() {
    return counter.getAndIncrement();
}

代码3

private volatile int counter;

public int getNextUniqueIndex() {
    return counter++; 
}

是否volatile以下列方式工作？是

volatile int i = 0;
void incIBy5() {
    i += 5;
}

相当于

Integer i = 5;
void incIBy5() {
    int temp;
    synchronized(i) { temp = i }
    synchronized(i) { i = temp + 5 }
}

我认为两个线程不能同时进入同步块...我是对的吗？如果这是真的那么如何atomic.incrementAndGet()工作没有synchronized …

我认为两者都在做同样的工作,你如何决定使用哪一个进行同步？

@synchronized不使用"锁定"和"解锁"来实现互斥吗？那怎么做锁定/解锁呢？

以下程序的输出仅为"Hello World".

@interface MyLock: NSLock<NSLocking>
@end

@implementation MyLock

- (id)init {
    return [super init];
}

- (void)lock {
    NSLog(@"before lock");
    [super lock];
    NSLog(@"after lock");
}

- (void)unlock {
    NSLog(@"before unlock");
    [super unlock];
    NSLog(@"after unlock");
}

@end


int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    MyLock *lock = [[MyLock new] autorelease];
    @synchronized(lock) {
        NSLog(@"Hello World");
    }

    [pool drain];
}

java.util.concurrentAPI提供了一个名为as的类Lock,它基本上将序列化控件以访问关键资源.它给出了诸如park()和的方法unpark().

我们可以做类似的事情,如果我们可以使用synchronized关键字,并使用wait()和notify() notifyAll()方法.

我想知道其中哪一个在实践中更好,为什么？

如果我有一个带有静态方法的util类,它将调用Hibernate函数来完成基本的数据访问.我想知道是否使用该方法synchronized是确保线程安全的正确方法.

我希望这可以防止信息访问同一个数据库实例.但是,我现在确定以下代码是否阻止getObjectById在特定类调用所有类时调用它们.

public class Utils {
     public static synchronized Object getObjectById (Class objclass, Long id) {
           // call hibernate class
         Session session = new Configuration().configure().buildSessionFactory().openSession();
         Object obj = session.load(objclass, id);
         session.close();
         return obj;
     }

     // other static methods
}

我是多线程的新手,并试图了解互斥锁的工作原理.很多谷歌和我找到了一个体面的教程,但它仍然有一些怀疑它是如何工作的,因为我创建了自己的程序,其中锁定不起作用.

互斥体的一个绝对非直观的语法是pthread_mutex_lock( &mutex1 );,当看起来互斥锁被锁定时,我真正想要锁定的是其他变量.这种语法是否意味着锁定互斥锁会锁定代码区域,直到互斥锁被解锁？然后线程如何知道该区域被锁定？[ 更新:线程知道该区域被 内存屏蔽锁定 ].这种现象应该被称为临界区吗？[ 更新:关键部分对象仅在Windows中可用,其中对象比互斥锁更快,并且仅对实现它的线程可见.否则,临界区只是指由互斥锁保护的代码区域 ]

简而言之,您能否帮助解决最简单的互斥示例程序以及关于它如何工作的逻辑的最简单的解释？我相信这会帮助很多其他新手.

有人可以解释之间的区别:

• 锁定(someobject){}
• 使用Mutex
• 使用信号量
• 使用Monitor
• 使用其他.Net同步类

我只是想不出来.在我看来前两个是一样的？