标签: synchronization

我注意到您可以调用Queue.Synchronize来获取线程安全的队列对象,但Queue <T>上没有相同的方法.有谁知道为什么？看起来有点奇怪.

在程序执行过程中,会启动许多线程.线程数量取决于用户定义的设置,但它们都使用不同的变量执行相同的方法.

在某些情况下,执行中需要清理,其中一部分是停止所有线程,我不希望它们立即停止,我只是设置一个他们检查的变量来终止它们.问题是它可以在线程停止前最多1/2秒.但是,我需要确保在清理可以继续之前所有线程都已停止.清理是从另一个线程执行的,所以从技术上讲,我需要这个线程来等待其他线程完成.

我想到了几种方法,但它们似乎都过于复杂.我希望有一些方法可以等待一组线程完成.有这样的事吗？

谢谢.

我不确定这是否是同步我的正确方法ArrayList.

我有一个ArrayList in_queue从registerInQueue函数传入的.

ArrayList<Record> in_queue = null;

public void registerInQueue(ArrayList in_queue)
{
    this.in_queue = in_queue;
}

现在我正在尝试同步它.这是否in_queue正确同步我的对象？

List<Record> in_queue_list = Collections.synchronizedList(in_queue);

synchronized (in_queue_list) {
    while (in_queue_list.size() > 0) {
        in_queue_list.remove(0);
    }
}

组织模式太棒了.我喜欢它的力量和简洁.但是,有时我需要在没有必要设置的地方访问我的任务.有没有办法将我的组织议程与RTM,Toodledo等类似的基于网络的todo服务同步？

这将是最好的解决方案,因为我会在我的计算机上定期自动运行同步过程,并且我可以通过同步服务的Web界面访问我的组织数据(读访问就足够了).

__syncthreads()在我有意使用线程丢弃的块中使用是否安全return？

文档说明__syncthreads() 必须由块中的每个线程调用,否则它将导致死锁,但实际上我从未经历过这样的行为.

示例代码:

__global__ void kernel(float* data, size_t size) {
    // Drop excess threads if user put too many in kernel call.
    // After the return, there are `size` active threads.
    if (threadIdx.x >= size) {
        return;
    }

    // ... do some work ...

    __syncthreads(); // Is this safe?

    // For the rest of the kernel, we need to drop one excess thread
    // After the return, there are `size - 1` active threads …

我对synchronizedJava 中块的性能有一点争议.这是一个理论问题,不影响现实生活中的应用.

考虑单线程应用程序,它使用锁定和同步部分.这个代码是否比没有同步部分的相同代码更慢？如果是这样,为什么？我们不讨论并发性,因为它只是单线程应用程序

更新

找到有趣的 基准测试吧.但它是从2001年开始的.在最新版本的JDK中,情况可能会发生巨大变化

性能如何std::mutex相比CRITICAL_SECTION？它是否相提并论？

我需要轻量级同步对象(不需要是一个进程间对象)是否有任何接近CRITICAL_SECTION其他的STL类std::mutex？

使用C#中的新async/await关键字,现在会对使用ThreadStatic数据的方式(以及何时)产生影响,因为回调委托在与async启动的操作不同的线程上执行.例如,以下简单的控制台应用程序:

[ThreadStatic]
private static string Secret;

static void Main(string[] args)
{
    Start().Wait();
    Console.ReadKey();
}

private static async Task Start()
{
    Secret = "moo moo";
    Console.WriteLine("Started on thread [{0}]", Thread.CurrentThread.ManagedThreadId);
    Console.WriteLine("Secret is [{0}]", Secret);

    await Sleepy();

    Console.WriteLine("Finished on thread [{0}]", Thread.CurrentThread.ManagedThreadId);
    Console.WriteLine("Secret is [{0}]", Secret);
}

private static async Task Sleepy()
{
    Console.WriteLine("Was on thread [{0}]", Thread.CurrentThread.ManagedThreadId);
    await Task.Delay(1000);
    Console.WriteLine("Now on thread [{0}]", Thread.CurrentThread.ManagedThreadId);
}

将输出以下内容:

Started on thread [9]
Secret is [moo moo]
Was on thread [9]
Now …

我一直认为在实现Runnable的java类中同步run方法是多余的.我试图找出人们为什么这样做:

public class ThreadedClass implements Runnable{
    //other stuff
    public synchronized void run(){
        while(true)
             //do some stuff in a thread
        }
    }
}

它似乎是多余的和不必要的,因为它们正在为另一个线程获取对象的锁.或者更确切地说,他们明确表示只有一个线程可以访问run()方法.但是由于它的run方法,它本身不是自己的线程吗？因此,只有它可以访问自己,它不需要一个单独的锁定机制？

我在网上发现了一个建议,通过同步run方法,你可以创建一个事实上的线程队列,例如:

 public void createThreadQueue(){
    ThreadedClass a = new ThreadedClass();
    new Thread(a, "First one").start();
    new Thread(a, "Second one, waiting on the first one").start();
    new Thread(a, "Third one, waiting on the other two...").start();
 }

我个人永远不会这样做,但它提出了为什么有人会同步run方法的问题.任何想法为什么或为什么不应该同步run方法？

我正在阅读Peter B. Galvin的"操作系统概念中的关键部分问题".根据它

1)进度是:如果没有进程在其关键部分执行,并且某些进程希望进入其关键部分,那么只有那些未在其余部分中执行的进程才能参与决定哪个进程将在下一个进入其关键部分,选择不能无限期推迟.

和

2)有界等待是:在进程请求进入其关键部分之后且在该请求被授予之前,允许其他进程进入其关键部分的次数存在约束或限制.

我不理解作者想要在两种情况下说什么.

您能否通过提供与此定义相关的适当示例来让我理解.

谢谢.