标签: locks

我是并发编程的新手.

我想反复执行三项任务.前两个应该一直运行,第三个应该每小时运行一次.前两个任务可以并行运行,但我总是希望在第三个任务运行时暂停它们.

这是我尝试过的骨架:

import threading
import time

flock = threading.Lock()
glock = threading.Lock()

def f():
    while True:
        with flock:
            print 'f'
            time.sleep(1)

def g():
    while True:
        with glock:
            print 'g'
            time.sleep(1)

def h():
    while True:
        with flock:
            with glock:
                print 'h'
        time.sleep(5)

threading.Thread(target=f).start()
threading.Thread(target=g).start()
threading.Thread(target=h).start()

我希望这段代码每秒打印一次f和ag,大约每五秒打一次.然而,当我运行它时,在我开始看到一些h之前需要大约12 f和12 g.它看起来像前两个线程不断释放并重新获取它们的锁,而第三个线程被排除在循环之外.

1. 这是为什么？当第三个线程试图获取当前持有的锁,然后它被释放时,不应该立即获取而不是第一个/第二个线程立即再次获取它？我可能误解了一些事情.
2. 什么是实现我想要的好方法？

注意:将这些time.sleep(1)调用移出with flock/glock块适用于这个简单的例子,但显然不适用于线程花费大部分时间进行实际操作的真实应用程序.当前两个线程在每次执行循环体后休眠一秒钟,并且释放锁定后,第三个任务仍然永远不会被执行.

我对SQL Server中的表上的锁定有疑问,同时使用多个进程将数据一次插入到同一个表中.

以下是我对此的问题,

1. 是否在执行插入时锁定表的SQL服务器的默认行为？
2. 如果是Q1,那么我们如何在插入数据时隐式提及.
3. 如果我有4个表,并且一个表具有来自3个表的其余部分的外键,在这种情况下我是否需要显式使用表锁,否则我可以将记录插入到这些表中？

请帮我理解一下.

我总是非常犹豫要把我的锁公开,让它们公开.我总是试图将锁限制在我的实现中.我相信,不这样做是一个僵局的秘诀.

我有以下课程:

class SomeClass {
    protected ArrayList<Listener> mListeners = new ArrayList<Listener>();

    protected void addListener(Listener listener) {
        synchronized (mListeners) {
            mListeners.add(listener);
        }
    }

    protected void removeListener(Listener listener) {
        synchronized (mListeners) {
            mListeners.remove(listener);
        }
    }

    ...
}

当SomeClass想要通知他的听众时,你会这样做:

    synchronized (mListeners) {
        for (Listener l : mListeners) {
             l.event();
        }
    }

要么

    Listener[] listeners = null;

    synchronized (mListeners) {
        listeners = mListeners.toArray();
    }
    for (Listener l : listeners) {
        l.event();
    }

我会选择第二种选择.缺点是听众可以获得活动,即使他们已经取消注册.好处是,一个侦听器calllback正在等待的线程,当他想取消注册一个监听器时,它不会遇到死锁.我认为好处比下行更重要,可以很容易地记录下来.

所以这里的问题基本上是:你会暴露你的锁吗？

我的问题不是你选择一个简单的ArrayList,LinkedList,ConcurrentLinkedQueue,CopyOnWriteArrayList,......!您是否会介意监听器是否可以在未注册时收到通知.无论你是否将锁打开,或不是.这是关于避免死锁.

请分享你的想法.谢谢!

我目前正在处理交易并感到困惑。这些事务是在数据访问层创建的，而不是在数据库（SQL Server 2008）的存储过程中创建的。我了解为事务设置的隔离级别的正常工作。我无法理解以下场景中会发生什么。

1. 发起交易
2. 选择 ID=1 的员工。
3. 更新员工 ID=1。
4. 犯罪

有多个线程在做同样的事情，但 ID 不同。但可能存在两个线程查找相同 ID 的情况。我们将它们称为线程 A 和 B。对于这两个线程，上述步骤按以下方式进行。隔离级别设置为可重复读取。

A1。发起交易A2。选择 ID=1 的员工。B1。发起交易B2。选择 ID=1 的员工。A3。更新员工 ID=1。A4。提交 B3。更新员工 ID=1。B4。犯罪

我真正想从事务中实现的是，当线程 A 选择特定记录时，线程 B 甚至不应该能够选择该记录。我不知道在这种情况下使用事务和锁是否走在正确的轨道上。

等待回复:)

一个程序将从一个表中选择几条记录并更新每一行，同时它可以执行多次，这将导致多个进程同时完成同一任务。

如何防止两个不同的进程更新表中的同一行。也就是说，如何确保每个进程可以选择不同的记录？MySQL中的行选择级别是否有锁？还是在这种情况下，有没有更好的解决方案来防止多次更新单个行？

我试图理解这些概念之间的关系。jpa锁是否是从Java在DB中提供/调用事务隔离级别的方法？还是它是分开的机制，所以有什么区别（它们的目的）？

我不能在连接语句中的表名后使用 NOLOCK。尝试通过 JOIN 读取未提交的数据是否是一个有效的场景

我知道通过同步静态和非静态方法来分别锁定类和实例的锁定概念。我无法理解的是，类级锁是如何实现的？我的意思是，类只是一个模板，没有物理意义。那么，当我们说通过同步静态方法实现类级锁定时，会发生什么？该类的所有对象是否都被锁定或其他一些进程？

通过我的搜索，我发现有类对象（Class.class）并且在这个类对象上获取了锁。但是，该类的所有实例又是如何被锁定的呢？

我是 Java 新手，在了解 Java 中的多线程时遇到了这个链接：http: //tutorials.jenkov.com/java-concurrency/slipped-conditions.html 。

在本教程中，以下代码被称为避免出现滑倒情况的良好实践：

public class Lock {

    private boolean isLocked = true;

    public void lock(){
      synchronized(this){
        while(isLocked){
          try{
            this.wait();
          } catch(InterruptedException e){
            //do nothing, keep waiting
          }
        }
        isLocked = true;
      }
    }

    public synchronized void unlock(){
      isLocked = false;
      this.notify();
    }

}

我的疑问是，如果两个线程 A 和 B 同时调用 lock() 并且 isLocked 为 true，即锁已被其他线程 C 占用。现在：

--1 A 首先进入同步块（因为只有一个人可以获得监视对象 this 的锁并进入同步块） --2 A 调用 this.wait() 并释放监视对象 this 的锁（wait() 调用）释放监视器对象上的锁http://tutorials.jenkov.com/java-concurrency/thread-signaling.html#wait-notify）但仍保留在同步块内 --3 现在 B 进入同步块（因为 A …

在 pthread_mutex_destroy 的 Linux 手册页中，有以下代码片段。关于销毁互斥锁​​的过程，我不明白的一件事是，我们如何知道在 pthread_mutex_unlock 和 pthread_mutex_destroy 之间没有其他线程尝试获取所述互斥锁上的锁？

通常情况下，应该如何处理？1）是否应该使用额外的互斥锁来确保这种情况不会发生？2）或者客户有责任在引用计数达到0后不尝试增加引用计数？

obj_done(struct obj *op)
{
    pthread_mutex_lock(&op->om);
    if (--op->refcnt == 0) {
        pthread_mutex_unlock(&op->om);
(A)     pthread_mutex_destroy(&op->om);
(B)     free(op);
    } else
(C)     pthread_mutex_unlock(&op->om);
}