javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

C ++-std :: thread-命名您的线程

新的C ++具有这种std :: thread类型。 奇迹般有效。现在,我想给每个线程起一个名称,以便更轻松地进行调试(例如java允许您这样做)。使用pthreads我可以:

pthread_setname_np(pthread_self(), "thread_name");

但是我该如何使用c ++ 0x呢?我知道它在Linux系统上使用pthreads,但是我想使我的应用程序具有可移植性。 有可能吗?

trans by 2020-01-26T13:54:08Z

多线程-Go goroutine是协程吗?

在Google I / O 2012演示文稿Go Concurrency Patterns中,Rob Pike提到了多个goroutine可以驻留在一个线程中。 这是否意味着它们被实现为协程? 如果没有,如何实施? 欢迎使用源代码链接。

trans by 2020-01-25T05:32:14Z

python-Lock和RL有什么区别

从文档:

threading.RLock()-   返回新的可重入锁定对象的工厂函数。 可重入锁必须由获取它的线程释放。 一旦线程获取了可重入锁,同一线程就可以再次获取它而不会阻塞; 线程必须在每次获取它后释放一次。

我不确定为什么我们需要这个?RlockLock有什么区别?

trans by 2020-01-24T21:15:53Z

进程和线程是什么?

是的,我已经阅读了许多与操作系统有关的资料。 而且我还在看书。 但是似乎所有人都以“抽象”的方式描述了进程和线程,这对它们的行为和逻辑组织作了大量的详细说明。 我想知道他们的身体是什么? 在我看来,它们只是一些内存中的“数据结构”,这些代码结构由内核代码维护和使用以促进程序的执行。 例如,操作系统使用某种过程数据结构(PCB)来描述为某个程序分配的过程的各个方面,例如其优先级,其地址空间等。 这样可以吗

trans by 2020-01-24T20:56:21Z

多线程-SMP内核,进程和线程如何精确地协同工作?

在单核CPU上,每个进程都在OS中运行,并且CPU从一个进程跳到另一个进程以充分利用自身。 一个进程可以具有许多线程,在这种情况下,当CPU在相应的进程上运行时,CPU将通过这些线程运行。

现在,在多核CPU上:

  • 核心是在每个进程中一起运行,还是可以在某个特定时间点在不同进程中分别运行? 例如,您的程序A运行两个线程。 双核CPU可以同时运行该程序的两个线程吗? 我认为,如果我们使用的是OpenMP,答案应该是肯定的。 但是,当内核在此OpenMP嵌入式进程中运行时,其中一个内核可以简单地切换到其他进程吗?

  • 对于为单核创建的程序,当以100%运行时,为什么每个核的CPU利用率都分布? (例如,双核CPU的利用率分别为80%和20%。在这种情况下,所有内核的利用率总和始终为100%。)内核是否尝试通过某种方式运行每个进程的每个线程来互相帮助?

trans by 2020-01-23T14:27:49Z

java-ScheduledExecutorService异常处理

我使用ScheduledExecutorService定期执行方法。

p码:

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
ScheduledFuture<?> handle =
        scheduler.scheduleWithFixedDelay(new Runnable() {
             public void run() { 
                 //Do business logic, may Exception occurs
             }
        }, 1, 10, TimeUnit.SECONDS);

我的问题:

如果run()抛出异常,如何继续调度程序?我应该尝试捕获方法run()中的所有Exception吗? 还是任何内置的回调方法来处理异常? 谢谢!

trans by 2020-01-23T06:44:38Z

iPhone-如何停止执行调度队列中的任务?

如果我有一个串行队列,如何从主线程告诉它立即停止执行并取消所有任务?

trans by 2020-01-22T09:40:20Z

java-什么时候应该使用多线程? 如果不同的线程执行相互独立的任务,多线程会有所好处吗?

这是我昨晚被拒绝的采访中唯一无法回答的两个问题。

trans by 2020-01-21T13:22:59Z

多线程-C#数组线程安全吗?

尤其是

  1. 创建一个函数以数组和索引作为参数。
  2. 创建一个n元素数组。
  3. 创建一个n计数循环。
  4. 在新线程的循环内,使用传入的索引器将对象的新实例分配给数组。

我知道如何管理线程等。我有兴趣知道这是否是线程安全的方法。

 class Program
{
    // bogus object
    class SomeObject
    {
        private int value1;
        private int value2;

        public SomeObject(int value1, int value2)
        {
            this.value1 = value1;
            this.value2 = value2;
        }
    }

    static void Main(string[] args)
    {

        var s = new SomeObject[10];
        var threads = Environment.ProcessorCount - 1;
        var stp = new SmartThreadPool(1000, threads, threads);
        for (var i = 0; i < 10; i++)
        {
            stp.QueueWorkItem(CreateElement, s, i);
        }

    }

    static void CreateElement(SomeObject[] s, int index)
    {
        s[index] = new SomeObject(index, 2);
    }
}
trans by 2020-01-20T19:51:39Z

多线程-Java中+ =运算符是线程安全的吗?

我发现以下Java代码。

for (int type = 0; type < typeCount; type++)
    synchronized(result) {
        result[type] += parts[type];
    }
}

其中+=synchronizeddouble[]

我知道基本类型的基本操作是线程安全的,但是我不确定+=。如果上面的synchronized是必需的,是否可能有更好的类来处理此类操作?

trans by 2020-01-20T19:08:09Z

队列已满时ThreadPoolExecutor块

我正在尝试使用ThreadPoolExecutor执行许多任务。 下面是一个假设的示例:

def workQueue = new ArrayBlockingQueue<Runnable>(3, false)
def threadPoolExecutor = new ThreadPoolExecutor(3, 3, 1L, TimeUnit.HOURS, workQueue)
for(int i = 0; i < 100000; i++)
    threadPoolExecutor.execute(runnable)

问题是由于任务数超出了工作队列的大小,因此我很快得到了java.util.concurrent.RejectedExecutionException。 但是,我正在寻找的理想行为是使主线程块直到队列中没有空间。 做到这一点的最佳方法是什么?

trans by 2020-01-20T18:43:29Z

为什么Monitor.PulseAll在发出信号的线程中导致“阶梯式”延迟模式?

在使用Monitor.PulseAll()进行线程同步的库中,我注意到从调用PulseAll(...)到唤醒线程的等待时间似乎遵循“阶梯式”分布-非常 大步。 唤醒的线程几乎没有任何作用。 几乎立即回到显示器上等待。 例如,在一个具有12个内核,24个线程的监视器上的盒子上(2个Xeon5680 / Gulftown;每个处理器6个物理内核;禁用HT),Pulse和线程唤醒之间的延迟如下:

Latency using Monitor.PulseAll(); 3rd party library

前12个线程(注意,我们有12个内核)需要30到60微秒的时间来响应。 然后我们开始出现很大的跳跃; 稳定时间大约为700、1300、1900和2600微秒。

我能够使用下面的代码独立于第三方库成功地重新创建此行为。 该代码的作用是启动大量线程(更改numThreads参数),这些线程仅在Monitor上等待,读取时间戳,将其记录到ConcurrentSet,然后立即返回Waiting。 第二次PulseAll()唤醒所有线程。 它会执行20次,并向控制台报告第10次迭代的延迟。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Diagnostics;

namespace PulseAllTest
{
    class Program
    {
        static long LastTimestamp;
        static long Iteration;
        static object SyncObj = new object();
        static Stopwatch s = new Stopwatch();
        static ConcurrentBag<Tuple<long, long>> IterationToTicks = new ConcurrentBag<Tuple<long, long>>();

        static void Main(string[] args)
        {
            long numThreads = 32;

            for (int i = 0; i < numThreads; ++i)
            {
                Task.Factory.StartNew(ReadLastTimestampAndPublish, TaskCreationOptions.LongRunning);
            }

            s.Start();
            for (int i = 0; i < 20; ++i)
            {
                lock (SyncObj)
                {
                    ++Iteration;
                    LastTimestamp = s.Elapsed.Ticks;
                    Monitor.PulseAll(SyncObj);
                }
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }

            Console.WriteLine(String.Join("\n",
                from n in IterationToTicks where n.Item1 == 10 orderby n.Item2 
                    select ((decimal)n.Item2)/TimeSpan.TicksPerMillisecond));
            Console.Read();
        }

        static void ReadLastTimestampAndPublish()
        {
            while(true)
            {
                lock(SyncObj)
                {
                    Monitor.Wait(SyncObj);
                }
                IterationToTicks.Add(Tuple.Create(Iteration, s.Elapsed.Ticks - LastTimestamp));
            }
        }
    }
}

使用上面的代码,下面是一个盒子上的延迟示例,该盒子上启用了8个内核/ w超线程(即任务管理器中的16个内核)和32个线程(* 2x Xeon5550 / Gainestown;每个处理器4个物理内核;启用了HT):

Latency using Monitor.PulseAll(), sample code

编辑:要尝试从公式中减去NUMA,下面是一个在Core i7-3770(Ivy Bridge)上以16个线程运行示例程序的图形; 4个物理核心; 启用HT:

Latency using Monitor.PulseAll(), sample code, no NUMA

谁能解释为什么Monitor.PulseAll()如此行为?

编辑2:

为了尝试表明这种行为不是同时唤醒多个线程所固有的,我使用事件复制了测试程序的行为。 而不是测量PulseAll()的等待时间,而是测量ManualResetEvent.Set()的等待时间。 该代码正在创建多个工作线程,然后在同一ManualResetEvent对象上等待ManualResetEvent.Set()事件。 触发事件后,他们会进行延迟测量,然后立即等待自己的每个线程的AutoResetEvent。 在下一次迭代之前(之前500毫秒),ManualResetEvent为Reset(),然后每个AutoResetEvent为Set(),以便线程可以返回以等待共享的ManualResetEvent。

我犹豫了一下,因为这可能是一个巨大的红色听证会(我不声称事件和监视器的行为类似),而且它正在使用一些绝对糟糕的做法来使事件的行为像监视器(我希望/讨厌看到我的 如果我将其提交给代码审查,则同事会做); 但我认为结果令人鼓舞。

该测试是在与原始测试相同的机器上完成的; 2xXeon5680 / Gulftown; 每个处理器6个内核(共12个内核); 禁用超线程。

ManualResetEventLatency

如果不是很明显,这与Monitor.PulseAll有何根本不同? 这是第一个覆盖在最后一个图形上的图形:

ManualResetEventLatency vs. Monitor Latency

用于生成这些度量的代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Diagnostics;

namespace MRETest
{
    class Program
    {
        static long LastTimestamp;
        static long Iteration;
        static ManualResetEventSlim MRES = new ManualResetEventSlim(false);
        static List<ReadLastTimestampAndPublish> Publishers = 
            new List<ReadLastTimestampAndPublish>();
        static Stopwatch s = new Stopwatch();
        static ConcurrentBag<Tuple<long, long>> IterationToTicks = 
            new ConcurrentBag<Tuple<long, long>>();

        static void Main(string[] args)
        {
            long numThreads = 24;
            s.Start();

            for (int i = 0; i < numThreads; ++i)
            {
                AutoResetEvent ares = new AutoResetEvent(false);
                ReadLastTimestampAndPublish spinner = new ReadLastTimestampAndPublish(
                    new AutoResetEvent(false));
                Task.Factory.StartNew(spinner.Spin, TaskCreationOptions.LongRunning);
                Publishers.Add(spinner);
            }

            for (int i = 0; i < 20; ++i)
            {
                ++Iteration;
                LastTimestamp = s.Elapsed.Ticks;
                MRES.Set();
                Thread.Sleep(500);
                MRES.Reset();
                foreach (ReadLastTimestampAndPublish publisher in Publishers)
                {
                    publisher.ARES.Set();
                }
                Thread.Sleep(500);
            }

            Console.WriteLine(String.Join("\n",
                from n in IterationToTicks where n.Item1 == 10 orderby n.Item2
                    select ((decimal)n.Item2) / TimeSpan.TicksPerMillisecond));
            Console.Read();
        }

        class ReadLastTimestampAndPublish
        {
            public AutoResetEvent ARES { get; private set; }

            public ReadLastTimestampAndPublish(AutoResetEvent ares)
            {
                this.ARES = ares;
            }

            public void Spin()
            {
                while (true)
                {
                    MRES.Wait();
                    IterationToTicks.Add(Tuple.Create(Iteration, s.Elapsed.Ticks - LastTimestamp));
                    ARES.WaitOne();
                }
            }
        }
    }
}
trans by 2020-01-20T18:15:08Z

ios-在Swi中创建线程安全数组

我在Swift中有一个线程问题。 我有一个数组,其中包含一些对象。 通过委托,该类大约每隔一秒钟就获得一个新对象。 之后,我必须检查对象是否已经在数组中,所以我必须更新对象,否则必须删除/添加新对象。

如果添加新对象,则必须首先通过网络获取一些数据。 这是通过块进行的。

现在我的问题是,如何同步这些任务?

我试过了dispatch_semaphore,但是这个阻塞了UI,直到阻塞完成。

我还尝试了一个简单的bool变量,该变量检查当前是否正在执行该块,并同时跳过compare方法。

但是两种方法都不理想。

管理阵列的最佳方法是什么,我不想在阵列中有重复的数据。

trans by 2020-01-20T08:17:41Z

多线程-J中的ThreadFactory用法

有人可以简要说明如何和何时使用ThreadFactory吗? 使用和不使用ThreadFactory的示例可能对理解这些差异很有帮助。

谢谢!

trans by 2020-01-20T07:58:19Z

为什么我们不能锁定值类型?

当我遇到以下错误时,我试图x一个xToTrue变量:

'bool'不是锁语句要求的引用类型

似乎x语句中仅允许使用引用类型,但是我不确定我为什么会这样。

Andreas在他的评论中指出:

当[值类型]对象从一个线程传递到另一个线程时,将进行复制,因此线程最终可以在2个不同的对象上工作,这是安全的。

是真的吗 这是否意味着当我执行以下操作时,实际上是在xToTruexToFalse方法中修改了两个不同的x

public static class Program {

    public static Boolean x = false;

    [STAThread]
    static void Main(string[] args) {

        var t = new Thread(() => xToTrue());
        t.Start();
        // ...
        xToFalse();
    }

    private static void xToTrue() {
        Program.x = true;
    }

    private static void xToFalse() {
        Program.x = false;
    }
}

(仅此代码在其状态下显然是无用的,仅用于示例)


附注:我知道有关如何正确锁定值类型的问题。 我的问题与如何无关,而与原因无关。

trans by 2020-01-20T07:11:38Z

python-朱莉娅的平行 特点和局限性

Julia的原始作者在arXiv论文中提到以下内容:

2.14 Parallelism。   并行执行由在标准库中的Julia中实现的基于消息的多处理系统提供。   语言设计通过以下方式支持此类库的实现:   提供对称的协程,也可以认为是   协同调度的线程。 此功能允许异步   通讯隐藏在库中,而不是要求   用户设置回调。 Julia目前不支持本机   线程,这是一个限制,但具有避免   共享内存同步使用的复杂性。

他们说Julia不支持本机线程是什么意思? 什么是本机线程?

其他解释语言(例如Python或R)是否支持这种并行性? 朱莉娅独自一人吗?

trans by 2020-01-19T21:06:34Z

android-为什么在runOnUiThread相同时使用处理程序?

我遇到过处理程序和runOnUiThread概念。 但是对我来说,这仍然是一个疑问,因为它们在哪些事实上完全不同。

它们都旨在从后台线程执行UI操作。 但是,当我们在两种方法中进行选择时,需要考虑哪些因素。

例如,考虑AsyncTask onPostExecute,它在后台执行Web服务,现在我想更新UI。

更新用户界面的最佳方法是什么? 我应该去AsyncTask还是onPostExecute

我仍然知道我可以使用AsyncTask并使用onPostExecute。但是我只是想知道区别。

trans by 2020-01-19T05:25:32Z

多线程-浏览器会为iframe提供一个单独的JavaScript线程吗?

网络浏览器是否在iframe中使用单独的JavaScript执行线程?

我认为Chrome为每个标签使用了单独的线程,因此我猜测iframe中的JavaScript与它的父窗口共享同一个线程,但是,这似乎也存在安全风险。

trans by 2020-01-18T21:42:08Z

多线程-.NET中的双重检查锁定

我碰到了这篇文章,讨论了为什么Java中破坏了双重检查锁定范式。 如果将变量声明为volatile,该范例对.NET(特别是C#)是否有效?

trans by 2020-01-17T18:01:52Z

Java-SwingUtilities.invokeL

我的问题与SwingUtilities.invokeLater有关。我什么时候应该使用它? 每次需要更新GUI组件时都需要使用吗? 它到底是做什么的? 因为听起来不直观并且添加了看似不必要的代码,所以还有其他替代方法吗?

trans by 2020-01-16T19:54:25Z

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 下一页 共24页