标签: synchronization

我喜欢对多个块进行 CUDA 同步。它并不是对于 __syncthreads() 可以轻松处理的每个块。

我看到关于这个主题的现有讨论，例如cuda 块同步，我喜欢 @johan 提出的简单解决方案， https: //stackoverflow.com/a/67252761/3188690，本质上它使用 64 位计数器跟踪同步块。

但是，我编写了以下代码试图完成类似的工作，但遇到了问题。这里我使用这个术语environment是为了使wkNumberEnvs这个环境中的块能够同步。它有一个柜台。我曾经atomicAdd()计算有多少块已经自己同步，一旦同步块的数量 == wkBlocksPerEnv，我就知道所有块都完成了同步，并且可以自由运行。然而，它有一个奇怪的结果，我不确定为什么。

问题就出在这个while循环上。由于所有块的第一个线程都在执行atomicAdd，因此有一个while循环来检查，直到条件满足。但我发现有些块会陷入无限循环，我不确定为什么最终无法满足条件？如果我在 或 中打印一些消息*** I can print here 1，*** I can print here 2则不会出现无限循环，一切都很完美。我没有看到明显的东西。

const int wkBlocksPerEnv = 2;

__device__ int env_sync_block_count[wkNumberEnvs];

__device__ void syncthreads_for_env(){
    // sync threads for each block so all threads in this block finished the previous tasks
    __syncthreads();

    // sync threads for wkBlocksPerEnv blocks for each environment …

我有一个问题,有什么区别

StringBuilder sb = new StringBuilder();
public void sync(){
  synchronized(sb){
  };
}

和

public void sync(){
  synchronized(this){
  };
}

如何为此代码块获取ConcurrentModificationException？

synchronized (list) {
        for (Iterator<?> it = list.iterator(); it.hasNext(); ) {
            Object object = it.next();
            // do something to object without touching list
        }
}

编辑:对不起,这不够具体://对对象执行某些操作不会触及列表

如何在第8或第16行发生死锁？

 1. public class DeadlockRisk {
 2.   private static class Resource {
 3.     public int value;
 4.   }
 5.   private Resource resourceA = new Resource();
 6.   private Resource resourceB = new Resource();
 7.   public int read() {
 8.     synchronized(resourceA) { 
 9.       synchronized(resourceB) {
10.         return resourceB.value + resourceA.value;
11.       }
12.     }
13.   }
14
15.   public void write(int a, int b) {
16.     synchronized(resourceB) { 
17.       synchronized(resourceA) {
18.         resourceA.value = a;
19.         resourceB.value = b;
20.       }
21. …

我已经读过,静态方法存储在JVM的类区域中.所以我们只有一个静态方法的副本.任何人都可以解释静态方法如何在java中为多个请求(使用多线程)并行运行.

我有一个方法,通过3个并发线程在对象实例上调用.我感兴趣的锁是基于价值而不是对象.例如,如果两个线程(T1,T2)正在处理RecordID = 123并且T3正在处理RecordID = 456.该方法应仅锁定T2,T3应继续执行.

目前,我正在使用Lock,但如果T1被锁定,它将锁定T2和T3.

public void doSomething(String id){
      try {
       lock.lock();
       MyRecord r = find(id);
       ...
       ....
       } finally{
         lock.unlock();
       }
}

class xyz {

    private Object lock = new Object();

    // value will come from database
    private boolean deleteOncePerDay; 

    private void clearAll() {
        synchronized (lock) {
            if(!deleteOncePerDay) {
                database.deleteNames();
                database.deleteAddresses();
                database.deletePhoneNums();

                // set database value to true
                deleteOncePerDay = true;
            }
        }   
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchNames() {
        clearAll();
        synchronized (lock) {
            database.saveNames();
        }
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchAddresses() {
        clearAll();
        synchronized (lock) {
            database.saveAddresses();
        }
    }

    @Scheduled(fixedDelay = 50000)
    public void fetchPhoneNums() {
        clearAll();
        synchronized (lock) …

我是多线程的初学者，有一个疑问：

java中的传统同步（使用synchronized关键字）是否有其他替代方案，因为它会影响应用程序的性能？

我有一段代码，我只想运行一次以进行初始化。到目前为止，我使用 sync.Mutex 结合 if 子句来测试它是否已经运行。后来我在同一个同步包中遇到了一次类型和它的 DO() 函数。

实现如下https://golang.org/src/sync/once.go：

func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

看代码，和我之前用的基本一样。与 if 子句结合的互斥锁。但是，添加的函数调用使这对我来说似乎效率很低。我做了一些测试并尝试了各种版本：

func test1() {
    o.Do(func() {
        // Do smth
    })
    wg.Done()
}

func test2() {
    m.Lock()
    if !b {
        func() {
            // Do smth
        }()
    }
    b = true
    m.Unlock()
    wg.Done()
}

func test3() {
    if !b {
        m.Lock() …

在 Java 应用程序中，如果对对象状态的访问发生在同一线程上（在最简单的情况下，在单线程应用程序中），则无需同步以强制更改的可见性/一致性，如发生在关系规范：

“两个动作可以通过先发生关系排序。如果一个动作先发生在另一个动作之前，那么第一个动作对第二个动作可见并在第二个动作之前排序。

如果我们有两个动作 x 和 y，我们写 hb(x, y) 来表示 x 发生在 y 之前。

如果 x 和 y 是同一线程的动作，并且 x 在程序顺序中排在 y 之前，则 hb(x, y)。”

但是现代架构是多核的，所以 Java 线程可以在任何给定时间在其中任何一个上执行（除非这不是真的并且 Java 线程被固定到特定的内核？）。因此，如果是这种情况，如果一个线程写入变量 x，将其缓存在 L1 缓存或 CPU 寄存器中，然后开始在另一个内核上运行，该内核先前访问过 x 并将其缓存在寄存器中，则该值是不一致的.. . 当线程从 CPU 上取下时是否有某种机制（隐式内存屏障）？