主页 / 问题

问题[многопоточность]

Martin Hope
Slava
Asked: 2023-09-08 06:24:08 +0800 CST
  • 5

Python 套接字、TCP

本质是这样的：有一个服务器，不同用户的信息随机地到达它。还有一个用户需要接收此信息。本质上是一个信使（虽然不是我写的）

我看到什么选项：

  1. 所有活动客户端都永久连接到服务器并准备好接收信息。但是，当用户数量较多时，服务器在维护连接方面的负载就会很高
  2. 客户端定期连接，向服务器询问新信息，接收它（如果有）并立即断开连接。如果处理器空闲等待，您可以使用线程同时处理多个用户。在这种情况下，不会花费大量资源来维护连接，但会出现延迟，并且更难以对用户进行优先级排序

请告诉我哪个选项更好或建议您自己的选项？）提前致谢！

многопоточность
Martin Hope
Denver Toha
Asked: 2022-08-22 01:21:27 +0800 CST
  • 3

原子写入和读取操作与加载/存储操作有何不同？我一直认为这是同一件事，但现在我有点困惑。

在查看了在标准原子上实现自旋锁的示例后，我感到困惑

struct tas_lock {
  std::atomic<bool> lock_ = {false};

  void lock() { while(lock_.exchange(true, std::memory_order_acquire)); }

  void unlock() { lock_.store(false, std::memory_order_release); }
};

文件说，这就是混乱所在

memory_order_acquire 具有此内存顺序的加载操作对受影响的内存位置执行获取操作：在此加载之前，当前线程中的任何读取或写入都不能重新排序。释放相同原子变量的其他线程中的所有写入在当前线程中可见（请参阅下面的 Release-Acquire 顺序）

我的意思是，获取是一个加载操作（在我对阅读的理解中），它保证了原子性并且任何读写操作都不会在它之前重新排序。

memory_order_release 具有此内存顺序的存储操作执行释放操作：当前线程中的任何读取或写入都不能在此存储之后重新排序。当前线程中的所有写入在获取相同原子变量的其他线程中可见（请参阅下面的 Release-Acquire 排序），并且将依赖项携带到原子变量中的写入在消耗相同原子的其他线程中变得可见（请参阅 Release-Consume下面订购）。

一个解除分配操作，以确保没有读/写操作可以在它之后重新排序。

但是在上面的例子中，写操作是用asquire保证的（在我的理解中，交换是读+写）

while(lock_.exchange(true, std::memory_order_acquire));

鉴于上述情况，加载/释放和读/写的概念不是一回事，它们有何不同？

PS：描述 std::atomic_flag 的文档中的措辞也具有误导性

std::atomic_flag 是一个原子布尔类型。与 std::atomic 的所有特化不同，它保证是无锁的。与 std::atomic 不同，std::atomic_flag 不提供加载或存储操作。

这里写到 atomic_flag 不提供加载/存储操作，当使用 asq / release 保证的相同文档的示例中描述类似的自旋锁时，这不是很清楚这意味着什么

c++ многопоточность
Martin Hope
Jumper
Asked: 2022-07-19 06:22:11 +0800 CST
  • 0

下午好！挑战在于一次运行多个异步函数。

现在我只有两个功能：第一个打开一个套接字并不断从这个连接接收数据；第二个周期性地向另一个服务器发出请求，并将对请求的响应和我们在第一个函数中收到的数据发送到 tg 通道。

问题是您可能需要打开更多套接字并编写像第二个这样的函数。是否可以并行执行异步函数？试图将 asyncio 与多处理和线程结合起来。对我来说没有任何结果。

这是我现在写的

import asyncio, json, time, aiohttp, websockets

async def func2(data):
    async with aiohttp.ClientSession() as session:
        async with session.post(url='...', json=data) as response:
            response = await response.json()
            # Обрабатываю response

async def func1():
    url = f'...'
    start_time = time.time()
    async with websockets.connect(url) as client:
        while True:
            data = json.loads(await client.recv())
            # Обрабатываю data
            if time.time() - start_time > 5*60:
                await gen_tasks()
                start_time = time.time()


async def gen_tasks():
    tasks = []
    for i in ...:
        data = {...}
        tasks.append(asyncio.create_task(func2(data)))
    for task in tasks:
        await task

asyncio.run(func1())
python многопоточность
Martin Hope
Klaus Köhler
Asked: 2022-07-18 01:48:27 +0800 CST
  • 0

有三个简单的线程。两个在运行中启动，第三个依次唤醒。

        Main main = new Main(); // экземпляр, по которому вызываем методы и синхронизируемся

    Thread thread1 = new Thread(() -> main.methodA());
    Thread thread2 = new Thread(() -> main.methodA());
    Thread thread3Notify = new Thread(() -> main.methodB());

这是一种方法，其唯一目的是让您入睡。

  public synchronized void methodA()   {
        System.out.println("I enter methodA" + Thread.currentThread());
                this.wait();
        System.out.println("I am awake " + Thread.currentThread());
}

我想依次唤醒两个线程的方法。

    public synchronized void methodB() {
    this.notifyAll();
    sleep(1000);
    this.notifyAll();
}

但问题是：我在控制台中看到了这个

I enter methodAThread[Thread-0,5,main]
I enter methodAThread[Thread-1,5,main]
I am awake Thread[Thread-0,5,main]

那些。methodB 只唤醒第一个线程，第二个线程永远挂在 methodA 中。我调用 this.notifyAll() 多少次都没关系

我试图自己弄清楚，但我做不到。

java многопоточность