标签: thread-synchronization

这是我在求职面试中提出的一个问题:

你有两个不同的类(实现Runnable)说EvenThread和OddThread.顾名思义,EvenThread只打印偶数,奇数线程只打印奇数,考虑范围为0-100.

class EvenThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <= 10; i += 2) {
            System.out.println(i);
        }
    }
}

class OddThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i < 10; i += 2) {
            System.out.println(i);
        }
    }
}

public class EvenOdd {

    public static void main(String args[]) {
        Thread tEven = new Thread(new EvenThread());
        Thread tOdd = new Thread(new OddThread());

        tEven.start();
        tOdd.start();
    }
} …

我正在寻找类似于这种语法的东西,即使它不存在.

我希望有一个方法作用于集合,并且在方法的生命周期中,确保集合不会被搞乱.

这可能看起来像:

private void synchronized(collectionX) doSomethingWithCollectionX() {
    // do something with collection x here, method acquires and releases lock on
    // collectionX automatically before and after the method is called
}

但相反,我担心这样做的唯一方法是:

private void doSomethingWithTheCollectionX(List<?> collectionX) {
    synchronized(collectionX) {
        // do something with collection x here
    }
}

这是最好的方法吗？

我被用来支持一些遗留代码,而且我看到一些让我困惑的事情.在代码的某些部分,我看到一个类实例使用CMutex实例来同步方法执行.例如

class CClassA : public CObject
{
public:
   void DoSomething();

private:
   CMutex m_mutex;
}

void CClassA::DoSomething()
{
   m_mutex.Lock();

   //...logic...

   m_mutex.Unlock();
}

在同一项目的其他地方,我发现代码使用的是CSingleLock

class CClassB : public CObject
{
public:
   void DoSomething();

private:
   CCriticalSection m_crit;
}

void CClassB::DoSomething()
{
   CSingleLock lock(&m_crit);
   lock.Lock();

   //...logic...

   lock.Unlock();
}

在查看MSDN文档以进行同步之后,似乎CClassB正在实施建议的方法,但我不清楚CClassA使用的实现中存在哪些危险.据我所知,这两种方法的唯一区别是CSingleLock具有RAII的优点,因此当执行退出范围时锁会自动释放.这两种实现都有其他好处/缺点吗？

我将不得不创建一个创建多个Task的并发软件,每个Task都可以生成另一个任务(也可以生成另一个Task,...).

我需要调用启动任务的方法阻塞:在完成所有任务和子任务之前不返回.

我知道有这个TaskCreationOptions.AttachedToParent属性,但我认为它不适合:

服务器至少会有8个内核,每个任务都会创建2-3 AttachedToParent个子任务,所以如果我设置了选项,我的印象是第二个子任务不会在第一个子任务的三个任务之前启动结束.所以我在这里将进行有限的多任务处理.

所以使用这个进程树:

我的印象是,如果我每次启动一个线程时都设置了AttachedToParent属性,那么在E,F,G完成之前B不会结束,所以C将在B完成之前启动,而我将只有3个活动线程而不是8个我可以有.

如果我没有放置AttachedToParent属性,A将很快完成并返回.

那么如果我没有设置这个选项,我怎么能确保我总是使用我的8个内核呢？

public class MyStack2 {
    private int[] values = new int[10];
    private int index = 0;

    public synchronized void push(int x) {
        if (index <= 9) {
            values[index] = x;
            Thread.yield();
            index++;
        }
    }

    public synchronized int pop() {
        if (index > 0) {
            index--;
            return values[index];
        } else {
            return -1;
        }
    }

    public synchronized String toString() {
        String reply = "";
        for (int i = 0; i < values.length; i++) {
            reply += values[i] + " ";
        }
        return …

我有这个非常简单的代码,很少抛出"System.ApplicationException:从非同步的代码块调用对象同步方法." 当调用ReleaseMutex()时.

我在逻辑上分析了方法的流程,并且无法理解这种情况如何/为何会发生.根据我的理解,在这种情况下保证互斥锁的所有权:

    readonly string mutexKey;

    public Logger(string dbServer, string dbName)
    {
        this.mutexKey = ServiceManagerHelper.GetServiceName(dbServer, dbName);
    }

    private void Log(LogType type, string message, Exception ex)
    {
        using (var mutex = new Mutex(false, mutexKey))
        {
            bool acquiredMutex;
            try
            {
                acquiredMutex = mutex.WaitOne(TimeSpan.FromSeconds(5));
            }
            catch (AbandonedMutexException)
            {
                acquiredMutex = true;
            }

            if (acquiredMutex)
            {
                try
                {

                    // some application code here

                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }
    }

我对在 for 循环内外使用互斥锁 () 和解锁 () 之间的速度不同感到困惑。我得到了一个全局变量值和一个将它增加 1000000 次的函数。此函数由 5 个线程并行运行。我测量了经过的时间并得到了这些结果：

    mutex.lock();
    for(int i = 0; i < 1000000; i++)
    {
        value++;
    }
    mutex.unlock();

0.160921 秒

和：

    for(int i = 0; i < 1000000; i++)
    {        
        mutex.lock();
        value++;
        mutex.unlock();
    }

2.10521 秒

我假设使用第二个内部互斥体排列控制太精细并且在线程切换之间花费了大量时间？或者还有别的东西吗？

我正在尝试使用 Java 中的线程。虽然我知道线程输出是不可预测的，但是想知道是否有办法做到这一点。

我必须实现两个线程，一个打印字母表(a,b,c...z)，另一个打印数字(1,2,3....26)。必须以输出应为a,1,b,2,c,3,d,4......z,26. 下面是我的代码，但它没有给出所需的输出。

public class ThreadsExample {

  public static void main(String[] args) {
    Runnable r = new Runnable1();
    Thread t = new Thread(r);
    Runnable r2 = new Runnable2();
    Thread t2 = new Thread(r2);
    t.start();
    t2.start();
  }
}

class Runnable2 implements Runnable{
  public void run(){
    for(char i='a';i<='z';i++) {
        System.out.print(i+",");
    }
  }
}

 class Runnable1 implements Runnable{
  public void run(){
    for(int i=1;i<=26;i++) {
       System.out.print(i+",");
    }
 }
}

我应该在代码中进行哪些调整以获得所需的输出？如何synchronization帮助这里？或者在使用 Threads 时真的有可能吗？

PS：这不是作业或练习。它的自学。

我想使用synchronized块作为flatMap的源码.但我需要使用此构造进行处理(方法processItem),而不仅仅是在创建内部源时.

每隔5分钟调用一次Observable(例如Observable.interval)

Observable.fromIterable(getSourceData())
.flatMapCompletable(item -> {
  synchronized(LockManager.getInstance().getLockObject(item.id)){
    return processItem(item)
          .subscribeOn(Schedulers.io());
  }
})

我的processsItem方法如下所示:

public Completable processItem(Item item){
  return mApiSource.getItemById(item.id)
    .flatMap(item -> 
      mItemRepository.replace(item)
    )
    .toCompletable();
}

两个内部方法都返回Single.

它是从服务器定期更新的方法的一部分.我需要序列化processItem方法调用(从服务器定期同步项目)和修改项目(更新,删除)的方法,这些方法是从其他项目类调用的(项目同步).

主要问题是定期更新可以重写新更新的项目.

其实我用这个解决方案:

用于更新新项目的链:

public Completable updateItem(Item item){
  return Completable.fromAction(() -> {
        synchronized(LockManager.getInstance().getLockObject(item.id)){
          mApiSource.update(item)
          .flatMap(item -> 
            mItemRepository.replace(item)
          )
          .toCompletable()
          .blockingAwait();
        }
      })
      .subscribeOn(Schedulers.io())
}

定期更新链:

Observable.fromIterable(getSourceData())
    .flatMapCompletable(item -> {
      Completable.fromAction(() ->{
        synchronized(LockManager.getInstance().getLockObject(item.id)){
          processItem(item).blockingAwait();
        }
      })
      .subscribeOn(Schedulers.io())
    });

我知道RxJava解决方案并不清楚.

你知道更好的解决方案吗？

All, Referring to the question in std::lock still caused deadlock

I still couldn't figure what is the problem in the below code. Can somebody please explain the problem and how to fix this? Why does it get hung? Pls help.

#include <iostream>
#include <mutex>
#include <thread>
using namespace std;

std::mutex m1;
std::mutex m2;

void func1()
{
    std::unique_lock<std::mutex> lock1(m1, std::defer_lock);
    printf("func1 lock m1\n");
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::unique_lock<std::mutex> lock2(m2, std::defer_lock);
    printf("func1 lock m2\n");
    std::lock(m1, m2);
    printf("func1 std lock\n");

}

void func2()
{
    std::unique_lock<std::mutex> lock1(m2, …