标签: synchronization

这是关于void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);函数调用。之前提到的中断状态存储在标志中，我们可以通过将其传递给spin_unlock_irqrestore函数来恢复它们。

但是我不知道值传递的标志如何在spin_lock_irqsave调用时捕获先前的中断状态。

有什么方法可以将 myList<string>与 a同步ComboBox？

我想要的是我的 ComboBox，它根据列表的变化自动更新它的内容。

我已经尝试使用该ComboBox.DataSource属性，但这不会更新 ComboBox，它只会填充一次，仅此而已，所以......

我会做一个假设的场景，只是为了清楚我需要知道什么。

假设我有一个经常更新的文件。

我需要通过几个不同的线程读取和解析这个文件。

每次重写此文件时，我都会唤醒一个条件互斥锁，以便其他线程可以为所欲为。

我的问题是：

如果我有 10000 个线程，第一个线程执行会阻塞其他 9999 个线程的执行吗？

它是并行工作还是同步工作？

下面是示例 Poco 线程程序，以了解互斥锁和线程同步。仍然看到同一程序的不同输出。

#include "Poco/ThreadPool.h"
#include "Poco/Thread.h"
#include "Poco/Runnable.h"
#include "Poco/Mutex.h"
#include <iostream>
#include <unistd.h>
using namespace std;

class HelloRunnable: public Poco::Runnable
{
    public:
        static int a;
        HelloRunnable(){
        }
        HelloRunnable(unsigned long n):_tID(n){
        }
        void run()
        {
            Poco::Mutex::ScopedLock lock(_mutex);
            std::cout << "==>> In Mutex thread " << _tID << endl;
            int i;
            for (i=0;i<50000;i++)
            {
                a = a+1;
            }
            Poco::Mutex::ScopedLock unlock(_mutex);
        }
    private:
        unsigned long _tID;
        Poco::Mutex _mutex;
};
int HelloRunnable::a = 0;
int main(int argc, char** argv)
{
    Poco::Thread thread1("one"), …

工作案例:

template<typename T>
class threadsafe_queue
{
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;

public:
    threadsafe_queue()
    {}

    threadsafe_queue(const threadsafe_queue& other)
    {
        std::lock_guard<std::mutex> lk(other.mut);
        data_queue=other.data_queue;
    }
};

案例应该会失败:注意不mutable上std::mutex mut;

template<typename T>
class threadsafe_queue
{
private:
    std::mutex mut;
    std::queue<T> data_queue;

public:
    threadsafe_queue()
    {}

    threadsafe_queue(const threadsafe_queue& other)
    {
        std::lock_guard<std::mutex> lk(other.mut);
        data_queue=other.data_queue;
    }
};

我已经尝试过上面列出的两种情况,并且编译没有问题.我假设内部lock_guard调用mutex :: lock函数,它本身不是const函数.

问题>为什么我们可以从复制构造函数中的const对象锁定互斥锁？

我正在制作一个网络爬虫.我传递的URL通过履带功能和解析它来获取定位标记的所有链接,那么我调用相同的履带式功能适用于所有那些使用单独的goroutine每一个URL网址.
但是如果在我得到响应之前发送请求并取消它,则该特定请求的所有注入仍然在运行.
现在我想要的是当我取消请求时,由于该请求而被调用的所有goroutine都停止了.
请指导.
以下是我的爬虫功能代码.

func crawler(c echo.Context, urlRec string, feed chan string, urlList *[]string, wg *sync.WaitGroup) {
    defer wg.Done()
    URL, _ := url.Parse(urlRec)
    response, err := http.Get(urlRec)
    if err != nil {
        log.Print(err)
        return
    }

    body := response.Body
    defer body.Close()

    tokenizer := html.NewTokenizer(body)
    flag := true
    for flag {
        tokenType := tokenizer.Next()
        switch {
        case tokenType == html.ErrorToken:
            flag = false
            break
        case tokenType == html.StartTagToken:
            token := tokenizer.Token()

            // Check if the token is an <a> …

这是我正在修复的大型多线程项目（我没有写过）。该应用程序挂在我正在跟踪的一些锁上。

我仔细检查了一下，并用所有的“ lock”语句替换了它，Monitor.TryEnter以便设置等待时间。我偶尔会遇到例外Monitor.Exit。

原来的风格是

private List<myClass> _myVar= new List<myClass>();

if (_myVar != null)
{
    lock (_myVar)
    {
        _myVar = newMyVar; // Where newMyVar is another List<myClass>
    }
}

我将上述所有锁替换为：

if (_myVar != null)
{
    bool lockTaken = false;
    try
    {
        Monitor.TryEnter(_myVar, new TimeSpan(0, 0, 5), ref lockTaken);
        if (lockTaken)
        {
            _myVar = newMyVar; // Where newMyVar is another List<myClass>
        }
    }
    finally
    {
        if (lockTaken) Monitor.Exit(_myVar);
    }
}

我得到的例外是

从一个未同步的代码块中调用了SynchronizationLockException对象同步方法

。如果是这样，为什么原始的锁语句也不会引发异常？

将Monitor.Exittry 放入catch并在出现异常时将其忽略就可以安全吗？

我读了sync.Pool设计，但发现有两种逻辑，为什么我们需要localPool来解决锁竞争。我们可以使用chan来实现一个。

使用频道的速度是的4倍sync.pool！

除了池可以清除对象外，它还有什么优势？

这是池实现和基准测试代码：

package client

import (
    "runtime"
    "sync"
    "testing"
)

type MPool chan interface{}


type A struct {
    s        string
    b        int
    overflow *[2]*[]*string 

}

var p = sync.Pool{
    New: func() interface{} { return new(A) },
}

var mp MPool = make(chan interface{}, 100)

func get() interface{} {
    select {
    case r := <-mp:
        return r
    default:
        return new(A)
    }
}

func put(a interface{}) {
    select {
    case mp <- a:
    default:
    }
    return …

我正在探索使用固定密钥同时访问地图的可能性,而没有锁定以提高性能.我以前用切片探索过类似的东西,似乎有效:

func TestConcurrentSlice(t *testing.T) {
    fixed := []int{1, 2, 3}
    wg := &sync.WaitGroup{}
    for i := 0; i < len(fixed); i++ {
        idx := i
        wg.Add(1)
        go func() {
            defer wg.Done()
            fixed[idx]++
        }()
    }
    wg.Wait()
    fmt.Printf("%v\n", fixed)
}

上面的代码将通过-race测试.

这让我有信心用固定大小的地图(固定数量的键)实现同样的事情,因为我假设如果键的数量没有改变,那么下划线数组(在地图中)不需要扩展,所以它我们可以安全地访问不同的例行程序中的不同密钥(不同的内存位置).所以我写了这个测试:

type simpleStruct struct {
    val int
}

func TestConcurrentAccessMap(t *testing.T) {
    fixed := map[string]*simpleStruct{
        "a": {0},
        "b": {0},
    }
    wg := &sync.WaitGroup{}
    // here I use array instead of iterating the map to avoid read access
    keys := []string{"a", "b"} …

我不会说英语而且我使用翻译.

我想知道我什么时候学习线程同步.

class MainApp
{
    static public int count = 0;
    static private object tLock = new object();

    static void plus()
    {
        for (int i = 0; i < 100; i++)
        {
            lock (tLock)
            {
                count++;
                Console.WriteLine("plus " + count);
                Thread.Sleep(1);
            }
        }
    }

    static void minus()
    {
        for (int i = 0; i < 100; i++)
        {
            lock (tLock)
            {
                count--;
                Console.WriteLine("minus " + count);
                Thread.Sleep(1);
            }
        }
    }

    static void Main()
    {
        Thread t1 = new Thread(new ThreadStart(plus)); …