我的应用程序有一些问题,只有当我安装它时才会重现,但如果我只是从Xcode运行应用程序,则不会重现.我想调试这个问题,但到目前为止我没有任何运气.我正在使用Xcode 5.1.1.这是我做的:
1)转到Product-> Scheme-> Edit Scheme-> Archive并将构建配置设置为Debug.
2)代码签名身份设置为iPhone Developer.
3)生成调试符号设置为是.
4)转到Product-> Archive,归档后,单击"Distribute",然后选择"Save for Enterprise或Ad Hoc Deployment".
5)选择了我的开发配置文件.
6)单击"导出"并导出.ipa文件.
7)使用iPhone配置实用程序将应用程序安装到设备上.
8)在设备上运行应用程序.
9)在Xcode中,转到Debug-> Attach To Process->通过PID或Name,输入应用程序名称.Xcode成功附加并表示在iPad上运行应用程序.
10)然而,当我在我的应用程序中执行某些操作时,我无法点击应该被击中的任何断点(如果我从Xcode安装并运行应用程序,则所有断点都被命中).
我错过了什么吗？
我试图在linux上使用强大的互斥锁来保护进程之间的资源,而在某些情况下,它们似乎不会以"健壮"的方式运行.通过"健壮"的方式,我的意思是如果拥有锁的进程已经终止,pthread_mutex_lock应该返回EOWNERDEAD.
这是不起作用的场景:
2个过程p1和p2.p1创建健壮的互斥锁并等待它(在用户输入之后).p2有2个线程:线程1映射到互斥锁并获取它.线程2(在线程1获取互斥锁之后)也映射到相同的互斥锁并等待它(因为线程1现在拥有它).另请注意,在p2-thread1已经获取后,p1开始在互斥锁上等待.
现在,如果我们终止p2,p1永远不会解锁(意味着它的pthread_mutex_lock永远不会返回),这与假定的"健壮性"相反,其中p1应该用EOWNERDEAD错误解除阻塞.
这是代码:
p1.cpp:
#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
struct MyMtx {
pthread_mutex_t m;
};
int main(int argc, char **argv)
{
int r;
pthread_mutexattr_t ma;
pthread_mutexattr_init(&ma);
pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setrobust_np(&ma, PTHREAD_MUTEX_ROBUST_NP);
int fd = shm_open("/test_mtx_p", O_RDWR|O_CREAT, 0666);
ftruncate(fd, sizeof(MyMtx));
MyMtx *m = (MyMtx *)mmap(NULL, sizeof(MyMtx),
PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0);
//close (fd);
pthread_mutex_init(&m->m, &ma);
puts("Press Enter to lock mutex");
fgetc(stdin);
puts("locking...");
r = pthread_mutex_lock(&m->m);
printf("pthread_mutex_lock returned %d\n", r); …我的问题是,当一个进程异常终止时(通过信号,它可能是SIGKILL,所以我们不能拦截它),是否有任何保证的顺序或原子性,其资源被释放？特别是,我对文件锁和共享内存感兴趣.
例如:
1)如果过程是坚持2个文件锁和异常终止,是它在所有可能的另一个进程试图锁定看到一个文件被锁定相同的文件和另一个被解锁？或者从其他进程的角度来看,释放文件锁原子的过程是什么？
如果它不是原子的,那么是否存在至少一个预定义的顺序,其中文件锁将被终止进程释放(例如,它们最初被锁定的顺序相反)？
2)我想使用文件锁来确保正确的共享内存初始化 - 映射到共享内存的进程将保持共享锁,并且想要映射到同一共享内存段的新进程将尝试测试该锁以查看是否需要执行初始化(如果需要,我可以在以后提供更多详细信息).
但是同样的问题出现在这里:如果一个持有文件锁并且也映射到共享内存段的进程异常终止,那么在共享内存自动取消映射后,另一个进程是否仍然可以看到文件锁被锁定？或者是从其他进程的角度取消映射共享内存段并解锁文件原子？
我想模仿BeagleBone Black.似乎QEMU是唯一支持ARM的Linux仿真的仿真器.但是我很难获得正确的模拟器.
我尝试使用qemu.org中的QEMU构建但似乎不支持机器"beagle"(也来自"qemu-system-arm -machine help"的输出并不是最小的beagle作为支持的机器).我发现一些帖子说Linaro有一个支持BeagleBone的qemu版本,并且可以在Ubuntu上使用apt-get安装它.还有一个youtube视频,其中包含说明:
https://www.youtube.com/watch?v=__6XmxOrL3o
然而,似乎指令不再有效.我有Ubuntu 14.04.我尝试了以下方法:
1)sudo add-apt-repository ppa:linaro-maintainers/tools
这超时并报告错误的PPA格式错误.
2)然后我按照这里的说明:
https://wiki.linaro.org/Platform/Systems/Repository
但是,添加这些存储库后,没有添加qemu,所以在我的apt存储库中,我只有来自qemu.org的qemu(不支持beaglebone)
3)然后我找到了这个页面:
https://launchpad.net/~linaro-maintainers/+archive/ubuntu/tools
所以我尝试了以下内容:
sudo add-apt-repository http://ppa.launchpad.net/linaro-maintainers/tools/ubuntu
然后还使用"sudo apt-key add"命令下载并添加了公钥.
这似乎是在做了"sudo apt-get update"和"apt-cache show qemu-system"之后我看到了以下内容:
包:qemu-system来源:qemu-linaro版本:2.2.0~rc3 + git8 + gdb12451-63linaro + trusty架构:amd64维护者:Ubuntu开发人员安装大小:133812取决于:qemu-linaro-keymaps,libasound2(> = 1.0 .16),libbluetooth3(> = 4.91),libbrlapi0.6,libc6(> = 2.15),libcurl3-gnutls(> = 7.16.3),libfdt1,libgcc1(> = 1:4.7),libgl1-mesa-glx | libgl1,libglib2.0-0(> = 2.24.0),libgnutls26(> = 2.12.17-0),libncurses5(> = 5.5-5~),libpixman-1-0(> = 0.15.16),libpng12 -0(> = 1.2.13-4),libpulse0(> = 1:0.99.1),libsasl2-2(> = 2.1.24),libsdl1.2debian(> = 1.2.11),libstdc ++ 6( > = 4.6),libtinfo5,libuuid1(> = 2.16),libvdeplug2,libx11-6,zlib1g(> = 1:1.2.0)建议:samba Breaks:qemu(<< 0.11.0-2),qemu-kvm-临时演员(<< 0.13.50-2011.02-0~rc1-0ubuntu1)取代:qemu(<< 0.11.0-2),qemu-kvm-extras(<< 0.13.50-2011.02-0~rc1-0ubuntu1) …
有几个问题：
如果我为 .Net 6.0 构建应用程序，它是否可以依赖于为早期运行时构建的库（例如 nuget 包）？我特别对 .Net 5.0 和 .Net Core 3.1 感兴趣。经过尝试，它似乎有效，但我找不到微软对此的任何官方答案/指南。也许有文档链接吗？
相反，如果我有一个为 .Net 5.0 构建的 SDK 样式项目，为 .Net 6.0 构建的应用程序可以使用它，还是我必须重新定位它？如果我的 SDK 项目是为 .Net Core 3.1 构建的怎么办？
如果上述问题的答案是肯定的，那么在同一个项目中支持多个 TFM的目的是什么？如果兼容的话为什么不直接使用最早的那个呢？特别是，如果我已经有针对 .Net 5.0 的 SDK 式项目，是否有任何理由使其同时包含 .Net 5.0 和 .Net 6.0 的多目标？
我有一个进程共享的pthread条件(与相关的互斥锁).如果等待此条件的进程(使用pthread_cond_wait()或pthread_cond_timedwait())终止会发生什么？这种情况是否仍可被其他进程使用？
在我的场景中,#1等待条件并终止.进程#2在某个时刻看到它是现在唯一使用该条件并调用pthread_cond_destroy()的进程.
我看到的是pthread_cond_destroy()只是挂起.有谁遇到过同样的问题？
从pthread_cond_destroy()的手册页中可以看出,破坏某些线程仍在等待的条件会导致未定义的行为.在我的情况下,当进程#2调用pthread_cond_destroy()时,没有人在等待,因为等待进程#1被终止,但显然条件本身仍然认为存在等待线程.
有没有解决这个问题的方法？
编辑:
每个请求,我发布示例程序(我在这里颠倒了p1和p2):
p1.cpp:
#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
struct MyCond {
pthread_mutex_t m;
pthread_cond_t c;
};
int main()
{
pthread_mutexattr_t ma;
pthread_mutexattr_init(&ma);
pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
pthread_condattr_t ca;
pthread_condattr_init(&ca);
pthread_condattr_setpshared(&ca, PTHREAD_PROCESS_SHARED);
int fd = shm_open("/test_cond_p", O_RDWR|O_CREAT, 0666);
ftruncate(fd, sizeof(MyCond));
MyCond *c = (MyCond *)mmap(NULL, sizeof(MyCond),
PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0);
//close (fd);
pthread_mutex_init(&c->m, &ma);
pthread_cond_init(&c->c, &ca);
printf("Inited MyCond, %x\n", c);
puts("Press Enter to continue");
fgetc(stdin);
int r = pthread_cond_signal(&c->c);
printf("After …我想使用Posix强大的互斥锁来保护不同进程之间的共享资源(在Linux上).然而,在不同情况下对安全性存在一些疑问.我有以下问题:
是否在内核或用户代码中实现了强大的互斥锁？
如果是后者,如果在调用pthread_mutex_lock或pthread_mutex_unlock并且共享的pthread_mutex数据结构更新时进程发生崩溃会发生什么？
我理解如果一个进程锁定互斥锁并死掉,另一个进程中的线程将被唤醒并返回EOWNERDEAD.但是,如果正在更新pthread_mutex数据结构(在共享内存中)时,如果进程死亡(在不太可能的情况下)会发生什么？在这种情况下,互斥锁会被破坏吗？如果要调用pthread_mutex函数,映射到同一共享内存的另一个进程会发生什么？在这种情况下,互斥锁是否仍然可以恢复？
此问题适用于具有PTHREAD_PROCESS_SHARED属性的任何pthread对象.在同一个来自不同进程的对象上同时调用pthread_mutex_lock,pthread_mutex_unlock,pthread_cond_signal等函数是否安全？它们是否在不同进程中是线程安全的？
我的问题是关于初始化使用shm_open()和获得的内存mmap()。我在几个地方看到的一个常见建议是shm_open()使用标志调用O_CREAT|O_EXCL：如果成功，则我们是共享内存的第一个用户并可以对其进行初始化，否则我们不是第一个用户，并且共享内存已被另一个进程初始化。
但是，根据我的了解shm_open以及在Linux上进行的测试，这是行不通的：即使在共享内存对象的最后一个用户未映射并关闭后，共享内存对象仍留在系统中。一个简单的测试程序，它要求shm_open有O_CREAT|O_EXCL，然后关闭描述符和退出，将在第一次运行成功，但仍然会失败的第二次运行，即使没有其他人使用当时的共享内存。
在我看来，实际上（至少在我测试的系统上）的行为与以下行为shm_open几乎完全相同open()：如果我修改我的简单测试程序以将某些内容写入共享内存（通过通过获取的指针mmap）并退出，则共享内存对象将永久保留其内容（我可以运行另一个简单程序以读取我先前编写的数据）。
那么，如何使用的意见shm_open与O_CREAT|O_EXCL刚才错了，还是我失去了一些东西？
我确实知道可以使用删除共享内存对象shm_unlink()，但似乎只会引起更多问题：
如果进程在调用之前死亡，shm_unlink()那么我们将回到上述问题。
如果一个进程调用shm_unlink()而其他进程仍映射到同一共享内存中，则这些其他进程仍将照常继续使用它。现在，如果另一个进程来shm_open()使用相同的名称并O_CREAT指定了名称，则它实际上将成功创建具有相同名称的新共享内存对象，这与其他进程仍在使用的旧共享内存对象完全无关。现在，我们有一个进程试图通过共享内存与其他进程进行通信，而完全不知道它使用了错误的通道。
我习惯了Windows语义，即只有打开了至少一个句柄，共享内存对象才会存在，因此Posix的内容非常令人困惑。
在 C# 中，使用 HttpClient 时，如何连接到使用自签名证书（用于测试）或不属于计算机信任存储的自定义 CA 的 https 服务器？请注意，我不需要客户端证书，只需要 HttpClient 来验证未由计算机上受信任的根 CA 之一签名的服务器证书。我知道我可以将自签名证书或 CA 添加到计算机上的本地信任存储中，但假设我想避免这样做。我需要的基本上是为正在运行的应用程序提供额外的根 CA。
据我所知，在其他语言中有很简单的方法可以做到这一点：
在java中，使用“javax.net.ssl.trustStore”系统属性。
在 Node.js 中，使用 NODE_EXTRA_CA_CERT 环境变量。
但到目前为止，我在 .Net 上找不到类似的东西。有没有像上面这样简单的方法呢？
我正在尝试使用 System.Net.Http 进行 POST 请求。我同意 HTTP 响应主体位于内存中，但需要为其获取 MemoryStream。一种方法是调用 HttpContent.GetAsByteArrayAsync() 并在其上包装 MemoryStream，但我认为这需要将内容复制到单独的字节数组中（因为它返回 byte[] 的任务）。
如果响应正文已经位于 HttpContent 中的某个内部缓冲区中，是否可以在该缓冲区顶部创建 MemoryStream，或者以某种方式从 HttpContent 返回 MemoryStream 并避免复制到单独的字节数组？
还有 HttpContent.GetAsStreamAsync()，但它返回常规 Stream，而不是 MemoryStream。尽管它可能已经是 MemoryStream 的一个实例，但我认为将返回的流转换为 MemoryStream 并不安全，也不是一个好的做法？（因为这是可能改变的实现细节）。
有没有其他方法可以做到这一点，或者我别无选择，只能先复制到 byte[] 中？
谢谢。
假设我有一个文件t.txt,其中包含许多包含'a'的行.我很疑惑为什么这不起作用:
cat <(tail -f t.txt | grep a)
上面的命令只是挂起而不打印任何内容,即使每行都有匹配.这是因为猫正在等待"尾巴"而不是"grep"的输出吗？我怎样才能解决这个问题？
顺便说一句,我尝试了另一种带有双重过程替换的变体:
cat <(grep a <(tail -f t.txt))
这也挂起而不打印任何东西.
有人有线索吗？