小编Tud*_*dor的帖子

我在博客文章中看到很多人,在这里要么避免或建议Thread在最近版本的C#中使用该类(我的意思当然是4.0+,添加了Task&friends).甚至在此之前,关于这样一个事实的辩论:在很多情况下,ThreadPool类可以替换普通旧线程的功能.

此外,其他专门机制进一步使Thread类不那么吸引人,例如Timers替换丑陋的Thread+ Sleep组合,而对于我们有的GUI BackgroundWorker等.

不过,Thread似乎仍然对一些人(包括我自己),人的是,当涉及某种并行执行的任务面前,直接跳转到使用好老的一个非常熟悉的概念Thread类.我最近一直想知道是否该修改我的方式.

所以我的问题是,在使用普通旧Thread对象而不是上述结构之一时,是否有必要或有用？

有人可以帮我一个关于如何使用共享内存的一个非常简单的例子吗？Cuda C编程指南中包含的示例似乎与不相关的细节混杂在一起.

例如,如果我将一个大型数组复制到设备全局内存并想要对每个元素求平方,那么如何使用共享内存来加快速度呢？或者在这种情况下它没用？

我知道你不能有一个OpenMP循环的break语句,但我想知道是否有任何解决方法,同时仍然受益于并行性.基本上我有'for'循环,循环遍历大向量的元素,寻找满足某个条件的一个元素.但是只有一个元素可以满足条件,所以一旦发现我们可以突破循环,提前谢谢

for(int i = 0; i <= 100000; ++i)
  {
    if(element[i] ...)
     {
          ....
          break;
      }
   }

正如标题所暗示的那样,我正在寻找一种比较和交换的实现,但是要比较大:

if(newValue > oldValue) {
    oldValue = newValue;
}

哪里oldValue是一些全局共享状态,并且newValue对每个线程都是私有的,而不执行以下操作:

synchronized(locker) {
    if(newValue > oldValue) {
        oldValue = newValue;
    }       
}

因为我想要一个非阻塞的解决方案.通过研究其他非阻塞操作的源代码,我想出了这个(假设值是整数):

AtomicInteger oldValue; // shared global variable

...

public boolean GreaterThanCAS(int newValue) {

    while(true) {
        int local = oldValue;
        if(local == oldValue) {
            if(newValue > local) {
                 if(oldValue.compareAndSet(local, newValue) {
                     return true;  // swap successful
                 } // else keep looping
            } else {
                 return false; // swap failed
            }
        } // else keep looping
    } …

我需要计算一次CUDA内核执行时间.最佳实践指南说我们可以使用clock()Windows中的事件或标准计时功能.我的问题是使用这两个函数给我一个完全不同的结果.事实上,事件给出的结果与实际的实际速度相比似乎是巨大的.

我真正需要的是通过首先在较小的数据集上运行它的简化版本来预测计算的运行时间.不幸的是,这个基准测试的结果是完全不现实的,要么过于乐观(clock())还是过于悲观(事件).

你可以告诉我是否应该在等待条件之前释放锁定？

try {
    lock.lock();
    while (isNotEmpty()) {
        condition.await();
    }
} finally {
    lock.unlock();
}

要么

try {
    lock.lock();
    while (isNotEmpty()) {
        lock.unlock();
        condition.await();
    }
} finally {
    lock.unlock();
}

这不是我的功课,这是给大学学生的一项任务.出于个人兴趣,我对解决方案感兴趣.

任务是创建一个包含整数的类(Calc).这两个方法add和mul应该添加或乘以这个整数.

同时设置两个线程.一个线程应该调用c.add(3)十次,另一个应该调用c.mul(3)十次(当然在同一个Calc对象上).

Calc类应确保操作交替完成(add,mul,add,mul,add,mul,..).

我没有经常处理与并发相关的问题 - 更不用说Java了.我已经为Calc提出了以下实现:

class Calc{

    private int sum = 0;
    //Is volatile actually needed? Or is bool atomic by default? Or it's read operation, at least.
    private volatile bool b = true;

    public void add(int i){
        while(!b){}
        synchronized(this){
                sum += i;
            b = true;   
        }
    }

    public void mul(int i){
        while(b){}
        synchronized(this){
            sum *= i;
            b = false;  
        }
    }

}

我想知道我是否走在正确的轨道上.对于while(b)部分来说,肯定有一种更优雅的方式.我想听听你们这些人的想法.

PS:不得更改方法的签名.除此之外,我不受限制.

我想大多数人都知道在Release模式下构建时会发生以下问题(代码取自C#中的Threading):

static void Main()
{
  bool complete = false; 

  var t = new Thread (() =>
  {
    bool toggle = false;
    while (!complete) toggle = !toggle;
  });

  t.Start();
  Thread.Sleep (1000);

  complete = true;
  t.Join();        // Blocks indefinitely
}

由于编译器优化缓存了值,complete从而阻止子线程看到更新的值.

但是,改变上面的代码:

class Wrapper
{
    public bool Complete { get; set; }
}

class Test
{
    Wrapper wrapper = new Wrapper();

    static void Main()
    {
        var test = new Test();
        var t = new Thread(() =>
        {
            bool …

什么是ReentrantLock#tryLock(long,TimeUnit)实现在尝试获取锁时执行的操作？假设线程A实际上拥有Lock of myLock和Thread B调用myLock.tryLock(10,SECONDS),是线程B正在休眠还是在等待？

换句话说,这是两个实现的区别:

1.

while (true)
   try {
     if (readLock.tryLock())
       return;
     MILLISECONDS.sleep(5);
   }catch (InterruptedException e) {}

2.

 while (true)
   try {
     if (readLock.tryLock(5,MILLISECONDS))
       return;
   }catch (InterruptedException e) {}

我正在考虑编写一个基于的TCP服务器epoll.为了实现最佳性能,我也希望实现多核支持.但是在我的研究过程中出现了以下问题:epoll_wait()从两个不同的线程调用两个-Call 是否更快,每个线程在双核上观察自己的文件描述符？或者这是否只调用一个epoll_wait()观察所有文件描述符的单个？

由于内核观察文件描述符,我认为在用户空间调用中使用多少线程并不重要epoll_wait()？