首先,我首先要解释为什么我首先要问这个问题:我正在编写一个python程序(带有一个wxPython gui),需要从python调用Java AWT程序并从中提取数据.我在Windows上有一个进程内工作解决方案.只要我无头地运行Java应用程序,我在OSX上也有一个进程内解决方案.遗憾的是,我找不到在OSX上在同一进程中运行两个GUI的合理解决方案,因为AWT和WX都想要第一个线程并且不能共享wx消息循环.
What I would like to do is to launch a Java program in a separate process from my Python program and establish a pipe or queue or something for passing data (specifically byte arrays) back and forth.
I'd greatly appreciate any suggestions, or even a nudge in the right direction as I have very little experience with IPC.
这段代码是我的操作系统项目的一部分,项目要求做一些应用并发进程的东西,我决定用两个玩家做一个客户服务器扑克项目,我用儿子和孙子进程来确定手牌价值.
代码中应用的方案如下:
1 http://f.cl.ly/items/2f3x3z1A3z1n3r2b0X0N/schema.jpg
代码的问题在于,在同一游戏中只有第一只手被正确评估,实际上第二只手是不正确的,而在第三局游戏中有错误并且程序结束,这发生在每一个新游戏中
这是代码:
void check_hand(int suits[5],int ranks[5],int *point){
pid_t son[2];
int i,j;
for (i = 0; i < 2; i++){
son[i]=fork();
/***********************************************
straight flush son
************************************************/
if(son[i]==0 && i==0){
pid_t grandson[3];
int k;
for(k=0;k<3;k++){
grandson[k]=fork();
if(grandson[k]==0 && k==0){
exit(F_highcard(ranks));
}
else if(grandson[k]==0 && k==1){
exit(F_flush(suits));
}
else if(grandson[k]==0 && k==2){
exit(F_straight(ranks));
}
else if(grandson[k]<0){
puts("fork failed");
exit(-1);
}
}
int exit_status_straight,exit_status_flush,exit_status_highcard;
//waiting his sons
waitpid(grandson[0],&exit_status_highcard,0);
waitpid(grandson[1],&exit_status_flush,0);
waitpid(grandson[2],&exit_status_straight,0);
/**checkpoint A****/
//elaborate the exit statuses and exit with a …我有应用程序启动子进程并stdout异步处理它.问题是异步操作需要一些时间,我希望负责进程执行的方法在所有异步IO操作完成后结束.
我有这样的代码:
using System.Diagnostics;
Process process = new Process();
// ...
process.OutputDataReceived += new DataReceivedEventHandler(this.OnRecvStdOut);
process.ErrorDataReceived += new DataReceivedEventHandler(this.OnRecvStdErr);
// ...
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// ...
process.WaitForExit();
现在我正在寻找一种方法告诉程序等待所有IO(OnRecvStdOut)操作完成.
我虽然使用了System.Threading类中的一个,但我不确定哪个类最适合这个以及如何执行此操作,最好的方法可能是:
public void OnRecvStdOut(...)
{
something.Increase();
// the stuff that takes so long
something.DecreaseAndSignal();
}
并在主要功能:
something.WaitUntilZero();
注:我想同时允许StdErr和StdOut并行处理. Something不能依赖那个Wait会被调用的Signal,因为Increase()和DecreaseAndSignal()对会在Wait发生之前被多次调用.
我想到的第二件事就是可以多次发出信号(无需处理信号)并在主函数中使用循环,如:
while( ioOperations > 0){
something.WaitForSignal(500);
}
我试图了解如何在Android中的应用程序之间进行通信 - 而不仅仅是在Activity实例之间.
我建立了一个"客户端",它将一个Messenger obj发送给一个服务(在Intent发送到服务中); 该服务创建一个Messageobj并使用它将其发送回'client' messenger.send(message).这工作正常,直到我尝试使用Message.obj来保存对象.
我在服务中创建了自己的Parcelable类MyParcelable并将其放入消息中.一切都有效,直到消息在"客户端"中被解组.unmarshall失败,因为'客户'无法访问MyParcelable该类.这是显而易见的-他们是在不同的包(说com.whatever.myclient和com.whatever.myserver).这完全是错误的方法吗？
我也尝试过创建Parcel并发送(两个应用程序都可以访问该类) - 但事实Parcel并非如此Parcelable.我已经阅读过关于正在使用的类加载器,但是不了解单独的应用程序中的单独的类加载器(进程,如果我在这方面理解Android架构).也就是说,如何对一个类加载器"教授"另一个类加载器中存在的类？当然看起来应该有一个明显的"这就是你如何做到",但我还没有看到它.
android marshalling unmarshalling parcelable multiple-processes
我正在尝试编写一个烧瓶扩展,需要在请求之间保留一些信息.当我使用单个进程运行Werkzeug时这很好用,但是当我运行多个进程时,我得到了一些我不理解的奇怪行为.以这个简单的应用程序为例:
from flask import Flask
app = Flask(__name__)
class Counter(object):
def __init__(self, app):
print('initializing a Counter object')
self.app = app
self.value = 0
def increment(self):
self.value += 1
print('Just incremented, current value is ', self.value)
counter = Counter(app)
@app.route('/')
def index():
for i in range(4):
counter.increment()
return 'index'
if __name__ == '__main__':
#scenario 1 - single process
#app.run()
#scenario 2 - threaded
#app.run(threaded=True)
#scenario 3 - two processes
app.run(processes=2)
对于前两个场景,它的行为完全符合我的预期:Counter对象初始化一次,然后随着对'/'路径的每个请求递增.当我使用第三个场景运行它(传递进程= 2)然后我得到它作为输出:
initializing a Counter object
* Running on http://127.0.0.1:5000/ (Press …我最近读了很多关于拜占庭容错的论文。有一个常见的证明，需要 3m+1 台计算机来处理 m 个拜占庭故障。一般证明是这样的：
存在三个“将军”：A、B、C。假设将军们是这样沟通的，其中C是“叛徒”：
A --> B "Attack", A --> C "Attack"
B --> A "Attack", B --> C "Attack"
C --> A "Attack", C --> B "Retreat"
A receives "Attack" from both sources, and will attack.
B receives "Attack" from A but "Retreat" from C and doesn't know what to do.
C is a traitor, so his action could be anything.
因此，我们不能保证大多数参与者会达成共识。
我有点理解这个证明，但似乎忽略了一个要点。A、B、C不也各自内部计算着要做什么吗？由于A和B是这里的“忠诚”将军，因此似乎“正确”的行动是进攻。难道B在决定做什么时不允许考虑他自己的计算吗？在这种情况下，他可以轻松打破相互冲突的 A&C 输入之间的联系并决定进攻。然后，A和B都进攻，问题就解决了。这是一个与经典的拜占庭将军问题不同的问题吗？
fault-tolerance distributed-computing distributed-system multiple-processes
我有 main() 函数，它生成两个单独的子进程。这两个子流程共享指标。如何共享两个流程的指标并保持更新？这是我的片段，以供更多理解。
from multiprocessing import Process
import prometheus_client as prom
from prometheus_client import Counter
# Metrics
c1 = prom.gauge('Counter1', 'Number of Request')
c2 = prom.gauge('Gauge1', 'Processing time in Seconds')
def process_abc():
while True:
#Some operations
c1.set(some_value)
c2.set(some_value)
time.sleep(10)
def process_xyz():
while True:
#Some operations
c1.set(some_value)
c2.set(some_value)
time.sleep(10)
def main():
prom.start_http_server(8080)
Process(target=process_abc).start()
Process(target=process_xyz).start()
if __name__ == "__main__":
main()
我能够在端点看到指标名称，但计数始终为零意味着它永远不会被子流程更新。
我正在使用gdb非常方便的多劣支持来调试进程树：
(gdb) set detach-on-fork off
(gdb) set schedule-multiple on
(gdb) set follow-fork-mode parent
(gdb) break PostgresMain
(gdb) break PostmasterMain
现在需要让事情运行，直到我在一些尚未产生的劣势中遇到未来的断点之一。
但是，gdb每当低级正常退出时似乎“有帮助”暂停，或者至少阻止对低级的清理以便其父级wait()可以返回：
(gdb) c
[New process 16505]
process 16505 is executing new program: /home/craig/pg/bdr/bin/pg_config
Reading symbols from /home/craig/pg/bdr/bin/pg_config...done.
[Inferior 2 (process 16505) exited normally]
(gdb) info inferior
Num Description Executable
* 2 <null> /home/craig/pg/bdr/bin/pg_config
1 process 16501 /usr/bin/make
(gdb) inferior 1
[Switching to inferior 1 [process 16501] (/usr/bin/make)]
[Switching to thread 1 (process 16501)] …我是 docker 新手，试图在 docker 中运行多个 python 进程。虽然不推荐，但它应该按照这里的建议工作“ https://docs.docker.com/engine/admin/multi-service_container/ ”
我的 Dockerfile ：
FROM custom_image
MAINTAINER Shubham
RUN apt-get update -y
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
ENTRYPOINT ["/bin/bash"]
CMD ["start.sh"]
开始.sh：
nohup python flask-app.py &
nohup python sink.py &
nohup python faceConsumer.py &
nohup python classifierConsumer.py &
nohup python demo.py &
echo lastLine
运行命令：
docker run --runtime=nvidia -p 5000:5000 out_image
是否可以在没有 supervisord 或 docker-compose …
单个 docker 容器适用于较少数量的并行进程，但是当我们将并行进程的数量增加到 20-30 时，进程执行会变慢。进程变得越来越慢，但 docker 仍然只使用了 30-40% 的 CPU。
我尝试了以下方法让 docker 使用适当的 cpu 并且不减慢进程-
即使在做了这两件事之后，容器仍然没有正确使用 cpu。我正在使用 docker exec 在单个运行的容器中启动多个进程。有没有什么有效的方法可以使用单个 docker 容器来执行多个进程或使容器使用 100% 的 cpu？
我使用的配置是
服务器 - aws ec2 t2.2Xlarge（8 核，32 GB 内存）
Docker 版本 - 18.09.7
操作系统- ubuntu 18.04
python ×4
docker ×2
android ×1
c ×1
c# ×1
containers ×1
debugging ×1
dockerfile ×1
flask ×1
fork ×1
gdb ×1
io ×1
ipc ×1
java ×1
marshalling ×1
metrics ×1
parcelable ×1
prometheus ×1
python-3.x ×1
shell ×1
werkzeug ×1