在 Unity 编辑器中，转到顶部菜单栏（ 文件 , 编辑、 资产 等...）。从 窗口 下拉到 PackageManager 。打开它。在包管理器中，转到窗口左上角，有一个以 packages: 开头的选项卡， 名称在此字段中 。单击它可以下拉一些选项。选择 Unity Registry 以免费访问 Unity 包含的所有模块和附加组件。在搜索栏中，输入 FBX Exporter。下载并阅读 API。导出网格应该没有问题。

如果您能提供更多细节，那将非常有帮助！生成的网格是否仅在运行时出现（即您只有在点击播放时才能看到它）？还是场景中的游戏对象？

• 如果它在场景中，您可以使用 Unity 包转换为 FBX，正如其他答案所建议的那样。您也可以关注此主题（ https://discussions.unity.com/t/export-unity-mesh-to-obj-or-fbx-format/525773 ）。它有点旧，但我相信它应该有帮助！
• 如果是在运行时，我认为这些插件可以工作！（ 在运行时将网格转换为 stl/obj/fbx )

我在 Ubuntu 24 上使用 Python 3.12。我有一个带有 pynput 的基本 Python 脚本，当按下向上箭头时，它会停止程序执行。在 Pycharm 中运行此脚本没有问题，但在

我在 Ubuntu 24 上使用 Python 3.12。我有一个带有 pynput 的基本 Python 脚本，当按下向上箭头时，它会停止程序执行。在 Pycharm 中运行此脚本没有问题，但在终端窗口中，除非终端未 聚焦 。这是我的代码：

from pynput.keyboard import Key, Listener

stop = False
def on_press(key):
    print(key)
    if key == Key.up:
        global stop
        stop = True


if __name__ == "__main__":
    listener = Listener(on_press=on_press)
    listener.start()
    while not stop:
        pass              # some other code goes here

替换 listener = Listener(on_press=on_press) 为

with Listener(on_press=on_press) as listener:
        listener.join()

直到失去焦点时才在终端上起作用。

我测试了你的代码；它对我来说很好用。我认为这与你在 Ubuntu 上的应用程序配置有关，因为无论终端是否处于焦点状态，它都应该仍然有效。

另外，在 shell 中运行这个会发生什么？我同意 @furas 的观点，这很可能与终端应用程序有关。（此外，导入

我目前有一个 python 程序，它只是将 \'hello world\' 发送到 discord webhook，我想知道保护 webhook 的最佳方法是什么，以便如果我要分发...

我目前有一个 python 程序，它只是向 discord webhook 发送 \'hello world\'，我想知道什么是保护 webhook 的最佳方法，以便如果我分发它，没有人可以反编译并获取 webhook，因为他们没有验证方法

我有一个 ubuntu 22.04.4 服务器，我的第一个想法是使用它作为代理，其中客户端将发送“hello world”，然后服务器将该消息转发到 webhook。但是我对 ubuntu 和一般服务器端的东西相当不熟悉，并且不知道最好的前进方式。

我认为在代码中混淆它的任何方法似乎都不安全，如果有人真的想找到它

如果我忽略了什么，或者把事情复杂化了，我 100% 愿意听取大家的意见

为了清晰起见，我期望它是一台 Windows 机器，向 ubuntu 发送 \'hello world\'，然后转发到 webhook

所考虑的服务器配备了两个 CPU，每个 CPU 有 24 个物理核心，并在 Ubuntu 23.10 上运行。我观察到我的一个 Python 脚本的速度明显变慢，其速度

所考虑的服务器配备了两个 CPU，每个 CPU 有 24 个物理核心，并在 Ubuntu 23.10 上运行。我发现我的一个 Python 脚本的速度明显变慢，使用线程时速度降低到 百分之一 。考虑到 Python 中线程有时会出现问题，我用 C 编写了一个简单的测试代码来进一步调查这个问题。此代码在其计算密集型部分不共享任何内存等。

以下是相关信息：

joe@galileo:~$ cat /proc/version
Linux version 6.5.0-28-generic (buildd@lcy02-amd64-001) (x86_64-linux-gnu-gcc-13 (Ubuntu 13.2.0-4ubuntu3) 13.2.0, GNU ld (GNU Binutils for Ubuntu) 2.41) #29-Ubuntu SMP PREEMPT_DYNAMIC Thu Mar 28 23:46:48 UTC 2024

CPU 是：

root@galileo:~# cat /proc/cpuinfo | grep "model name" | head -1
model name  : Intel(R) Xeon(R) Gold 5118 CPU @ 2.30GHz

测试C代码：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>

int _memsize;
int _N;

double time_usec(void) {
    struct timeval tv;
    if (gettimeofday(&tv, NULL) == 0) {
        // Convert seconds to double and add microseconds divided by 1,000,000
        return tv.tv_sec + tv.tv_usec / 1000000.0;
    } else {
        // gettimeofday failed, handle error as appropriate
        perror("gettimeofday failed");
        return 0.0;
    }
}

void *test(void *arg) {
    int M = 10000;
    double t0, t1;
    int count;
    int tot;
    unsigned char *mem;
    long int id = (long int)arg;

    int N = _N;
    int memsize = _memsize;


    printf("Threads=%d   memsize=%d\n", N, memsize);
    mem = (unsigned char *)malloc(memsize);

    for (int i=0;i<memsize;i++) mem[i] = random();

    t0 = time_usec();
    count = 0;
    tot = 0;
    while (1) {
        for (int i = 0; i < M; i++) {
            tot += mem[(rand())%memsize];
            if (tot>10000000) tot -= 10000000;
            count++;
        }
        t1 = time_usec();
        if ((t1-t0)>2.0) {
            double nop_per_sec = (double)count / (t1-t0);
            t0 = t1;
            printf("%3ld  %15.2lf nop/sec\n", id, nop_per_sec/1000000.0);
            count = 0;
            M = nop_per_sec*0.1;
        }
    }
    pthread_exit(NULL);
}


int main(int argn, char *arg[]) {
    pthread_t thread;
    int rc;
    long t;

    _N = atoi(arg[1]);
    _memsize = atoi(arg[2]);


    for (t = 0; t < _N; t++) {
        printf("Creating thread %ld\n", t);
        rc = pthread_create(&thread, NULL, test, (void *)t);
        if (rc) {
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }

    while (1) sleep(1);

    return 0;
}

使用单线程时的性能：

joe@galileo:~$ ./perf 1 1000
Creating thread 0
Threads=1   memsize=1000
  0            60.61 nop/sec
  0            60.97 nop/sec
  0            61.05 nop/sec
  0            61.05 nop/sec

显示每秒 60M 次操作（任意但一致的单位）。当我使用 2 个线程时：

joe@galileo:~$ ./perf 2 1000
Creating thread 0
Creating thread 1
Threads=2   memsize=1000
Threads=2   memsize=1000
  0             0.79 nop/sec
  1             0.71 nop/sec
  0             0.80 nop/sec
  1             0.72 nop/sec
  0             0.79 nop/sec
  1             0.67 nop/sec

这表明速度减慢了约 1/100。CPU 负载约为 200%，正如预期的那样。当我运行两个进程，每个进程都有一个线程时，我没有观察到这种减慢：

joe@galileo:~$ ./perf 1 1000 & ./perf 1 1000
[1] 4989
Creating thread 0
Threads=1   memsize=1000
Creating thread 0
Threads=1   memsize=1000
  0            60.76 nop/sec
  0            60.76 nop/sec
  0            61.48 nop/sec
  0            61.48 nop/sec
  0            61.44 nop/sec

调度值如下：

root@galileo:~# sysctl -a | grep sched
kernel.sched_autogroup_enabled = 1
kernel.sched_cfs_bandwidth_slice_us = 5000
kernel.sched_child_runs_first = 0
kernel.sched_deadline_period_max_us = 4194304
kernel.sched_deadline_period_min_us = 100
kernel.sched_energy_aware = 1
kernel.sched_rr_timeslice_ms = 100
kernel.sched_rt_period_us = 1000000
kernel.sched_rt_runtime_us = 950000
kernel.sched_schedstats = 0
kernel.sched_util_clamp_max = 1024
kernel.sched_util_clamp_min = 1024
kernel.sched_util_clamp_min_rt_default = 1024

我尝试了调度设置以取得效果。\'perf stat\' 产生有问题的 \'LLC-load-misses\' 和 \'iTLB-load-misses\'，如下所示：

joe@galileo:~$ sudo perf stat -d -d -d --timeout 10000 ./perf 2 1000
Creating thread 0
Creating thread 1
Threads=2   memsize=1000
Threads=2   memsize=1000
  1             1.21 nop/sec
  0             0.76 nop/sec
  0             0.72 nop/sec
  1             1.00 nop/sec
  0             2.30 nop/sec
  1             1.30 nop/sec
  1             1.28 nop/sec
  0             2.32 nop/sec
./perf: Terminated

 Performance counter stats for './perf 2 1000':

         19,875.36 msec task-clock                       #    1.985 CPUs utilized             
            24,396      context-switches                 #    1.227 K/sec                     
                 0      cpu-migrations                   #    0.000 /sec                      
               100      page-faults                      #    5.031 /sec                      
    62,051,572,900      cycles                           #    3.122 GHz                         (38.44%)
    12,305,915,977      instructions                     #    0.20  insn per cycle              (46.07%)
     1,770,935,151      branches                         #   89.102 M/sec                       (46.19%)
        20,833,461      branch-misses                    #    1.18% of all branches             (46.14%)
     2,886,437,444      L1-dcache-loads                  #  145.227 M/sec                       (46.08%)
        62,673,587      L1-dcache-load-misses            #    2.17% of all L1-dcache accesses   (46.16%)
        36,380,110      LLC-loads                        #    1.830 M/sec                       (30.73%)
        36,335,895      LLC-load-misses                  #   99.88% of all L1-icache accesses   (30.80%)
   <not supported>      L1-icache-loads                                                       
        14,122,757      L1-icache-load-misses                                                   (30.91%)
     2,893,359,729      dTLB-loads                       #  145.575 M/sec                       (30.77%)
        15,591,131      dTLB-load-misses                 #    0.54% of all dTLB cache accesses  (30.84%)
           154,787      iTLB-loads                       #    7.788 K/sec                       (30.91%)
        30,148,243      iTLB-load-misses                 # 19477.24% of all iTLB cache accesses  (30.72%)
   <not supported>      L1-dcache-prefetches                                                  
   <not supported>      L1-dcache-prefetch-misses                                             

      10.010814854 seconds time elapsed

      11.662038000 seconds user
       8.215249000 seconds sys

我觉得这很奇怪。使用 gcloud 或 AWS EC2 时，我没有遇到这样的减速。这似乎破坏了线程的整体目的。

有人有什么见解吗？

哦，顺便说一句，模数是出了名的慢。它们应该比 L1 缓存中的内存访问慢，甚至可能比 L2 缓存延迟还要低。最好使用移位（对于 2 的幂值）或编译时已知的值。最重要的是，模数不适合在一定范围内生成随机值，因为这种方法在统计上有偏差（分布是

谢谢，Jérôme Richard。我的错误是在测试代码的线程环境中使用了 rand/random。一旦我切换到线程安全的替代方案，测试代码的表现就会符合预期。然而，这让我回到了最初的问题：当线程数超过核心数时，总体性能会突然下降。从 48 个线程到 49 个线程，性能会下降到 48 线程版本的十分之一左右。我将使用新的测试代码进一步调查这个问题，并通过新问题分享我的发现。也感谢其他评论。

我正在尝试在 ubuntu 服务器中运行一个 cron 作业来每天备份我的数据库。因此我使用这个 cmd：sudo -i -u postgres && pg_dump -Fc DbName > DbName_backup.dump && ... &&a...

我正在尝试在 ubuntu 服务器中运行一个 cron 作业来每天备份我的数据库。

所以我使用这个 cmd：

sudo -i -u postgres && pg_dump -Fc DbName > DbName_backup.dump && ... && ... && ...

我遇到的问题是您无法在单个语句中切换用户并运行命令，它永远不起作用。

我必须 sudo -i -u postgres 在另一个语句中 pg_dump -Fc DbName > DbName_backup.dump && ... && ... && ...

但我希望它在一条语句中起作用。在一行中！！！

@clamp 谢谢回复，我正在使用的 cron 作业是我使用的 GUI 软件。让我们忘记 cron，有没有办法直接在终端内运行此命令并正常工作？

sudo 不会“切换用户”；它会 以 另一个用户的身份运行单个命令。您可以将该单个命令作为单独的 shell 实例，用于解析和执行列表的其余部分。

sudo -i -u postgres sh -c 'pgdump -Fc DbName > DbName_backup.dump && ... && ... && ...'

这增加了一层引用，这可能会使提供论据变得 sh -c 更加困难。因此，您可以考虑将命令放在一个文件中，作为单个脚本执行。