我正在制作一个必须响应应用程序请求的DLL.应用程序的要求之一是调用不需要很长时间才能完成.
说,我有一个函数foo(),由宿主应用程序调用:
int foo(arg){
// some code i need to execute, say,
LengthyRoutine();
return 0;
}
可以说,foo必须执行一项确定需要很长时间的任务(或调用函数).该应用程序允许我设置一个等待变量; 如果foo返回时此变量为非零,则会一次又一次地调用foo(在每次调用之前重置wait变量),直到wait返回0.
什么是最好的方法？
我去吧
int foo(arg){
if (inRoutine == TRUE) {
wait = 1;
return 0;
} else {
if (doRoutine == TRUE) {
LengthyRoutine();
return 0;
}
}
return 0;
}
这并没有真正解决LongyRoutine需要很长时间才能完成的问题.我是否应该生成某种类型的线程,根据它是否已完成其任务,更新inRoutine？
谢谢..
可能重复:
ExecutorService,如何等待所有任务完成
Java ExecutorService:awaitTermination所有递归创建的任务
有没有办法阻止当前线程,直到ExecutorService完成所有任务？
executor.execute(task1);
executor.execute(task2);
executor.execute(task3);
executor.execute(task4);
executor.execute(task5);
// ...now I want to block until all tasks have finished executing...
System.out.println("done!")
我的网站上有不受欢迎的流量.例如.
这种类型的流量不会给我任何好处,而是使用带宽.
我想知道如何在我的网站上检测这种类型的流量并阻止它们.
如果我知道ip地址或referer url然后我阻止来自htaccess的ip或referer url.但在这种情况下,我每次都添加ip或referer url.我想要它自动化.类似的东西检测或识别垃圾邮件命中并阻止它们.
在node.js中,如果我的线程调用了一个阻塞库,那么在它从库中获取响应之前,它不能再接受任何请求.这是与Erlang虚拟机相同的情况 - 即,如果其中一个进程调用阻塞库,其他进程是否可以继续接受请求？
我不明白为什么我的主UI线程被阻止.我有调用函数doSomething()的按钮.
randomButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
doSomething();
}
});
}
// My private helper funtion
private void doSomething() {
Thread t1 = new Thread() {
@Override
public void run() {
long startTime = SystemClock.uptimeMillis();
Log.e(TAG, "Start Time = "+startTime);
while((SystemClock.uptimeMillis()-startTime)<6000){// Loop for 6 seconds
Log.e(TAG, "Diff ="+(SystemClock.uptimeMillis()-startTime));
}
}
};
t1.run();
}
问题是当我按下按钮时,它仍然按下循环运行的时间(这里是6秒).我希望它以这样一种方式,即使循环继续运行,用户仍然可以使用他的UI元素.这就是我创建一个新线程的原因.难道我做错了什么 ？
谢谢
我有一个简单的GenServer内容,我希望创建一个每两秒调用一次函数的循环:
defmodule MyModule do
use GenServer
def start_link(time) do
GenServer.start_link(__MODULE__,time)
end
#Start loop
def init(time) do
{:ok, myLoop(time)}
end
#Loop every two seconds
def myLoop(time) do
foo = bah(:someOtherProcess, {time})
IO.puts("The function value was: #{foo}")
:timer.sleep(2000)
myLoop(time + 2)
end
end
但是当我打电话给:
{:ok, myServer} =MyModule.start_link(time)
IO.puts("Now I can carry on...")
我从来没有看到上述电话的回复.我觉得这很明显.所以我的问题是,如何在不阻止下游执行任务的过程的情况下创建我想要的循环？
谢谢.
我正在Linux上编写一个C程序,我有一个main()和两个由它创建的pthread.在其中一个pthreads中,我调用了accept()函数.
我有一个信号处理程序,在收到SIGINT,SIGQUIT或SIGTERM时调用.
我的期望是,因为我正在使SA_RESTART标志为零,当我按下ctrl-c时,accept()函数应返回EINTR而不是重新启动,但是我在调试时通过一堆printf调用实现(看看哪些行是通过打印执行的)代码所在的地方,即使我的应用程序能够捕获SIGINT,接受函数仍然被阻塞,它不会因EINTR而失败并且不会移动到下一行代码.这是我在main()中的设置
struct sigaction signal_action;
signal_action.sa_flags = 0; // Don't restart the blocking call after it failed with EINTR
signal_action.sa_handler = terminate;
sigemptyset(&signal_action.sa_mask);
sigfillset(&signal_action.sa_mask); // Block every signal during the handler is executing
if (sigaction(SIGINT, &signal_action, NULL) < 0) {
perror("error handling SIGINT");
}
if (sigaction(SIGTERM, &signal_action, NULL) < 0) {
perror("error handling SIGTERM");
}
if (sigaction(SIGQUIT, &signal_action, NULL) < 0) {
perror("error handling SIGQUIT");
}
这是信号处理程序:
void terminate (int signum)
{
terminate_program = 1;
printf("Terminating.\n");
}
这是调用accept()的pthread(我试图删除不相关的东西,使我的问题更容易理解):
void* …我有一个带阻塞调用的Delphi 10多线程应用程序.当我退出时,有时不会从RAM卸载并且Delphi调试器不会停止.
如何(工具,方法)检测我的应用程序在哪个例程中等待？
我一直在研究Golang,看看它通过其创新的goroutines构造实现了一个仅限协程通道的模型,它的并发性有多好.
我立即发现令人不安的一件事是使用该Wait()方法,用于等待父母goroutine中产生的多个突出的goroutine已经完成.引用Golang文档
等待可以用来阻止所有goroutines完成
许多开发人员规定 Wait()作为实现并发性的首选方式的事实似乎与Golang使开发人员编写高效软件的使命相对立,因为阻塞效率低下,真正的异步代码永远不会阻塞.
被阻止的进程[或线程]是等待某个事件的进程[或线程],例如资源变为可用或完成I/O操作.
换句话说,被阻塞的线程将花费CPU周期无用,只需反复检查以查看其当前正在运行的任务是否可以停止等待并继续执行.
在真正的异步代码中,当协同程序遇到无法继续直到结果到达的情况时,它必须通过将其状态从运行切换到等待来将其执行发送到调度程序而不是阻塞,因此调度程序可以开始执行下一个 -来自可运行队列的内联协程.只有在需要的结果到达时,等待协程才应将其状态从等待运行变为可运行.
因此,由于Wait()直到x个goroutine被调用的块,调用Done()的goroutine Wait()将始终保持在可运行或运行状态,浪费CPU周期并依赖调度程序抢占长时间运行的goroutine,仅将其状态从运行更改为可运行,而不是将其更改为等待它应该是.
如果这一切都是真的,并且我理解如何Wait()正常工作,那么为什么人们不使用内置的Go通道来完成等待子goroutine的任务呢？如果我理解正确,发送到缓冲通道,并从任何通道读取都是异步操作,这意味着调用它们会使goroutine进入等待状态,那么为什么它们不是首选方法呢？
我引用的文章给出了一些例子.以下是作者所谓的"老派"方式:
package main
import (
"fmt"
"time"
)
func main() {
messages := make(chan int)
go func() {
time.Sleep(time.Second * 3)
messages <- 1
}()
go func() {
time.Sleep(time.Second * 2)
messages <- 2
}()
go func() {
time.Sleep(time.Second * …