我有许多线程(100),每次执行几秒钟.当它们执行时,它们花费大量时间等待来自另一个系统(串行设备)的响应.我注意到一次执行100个线程可能是资源占用,所以我实际上限制了任何时候都可以启动的线程数.
虽然在线程中等待外部事件必须有好的和坏的方法,但我想到了这一点.这种方法是CPU密集型的吗？:
send command ;
repeat
until response arrived ;
process response ;
这种方法是否会提高效率？:
send command ;
repeat
Sleep (20) ;
until response arrived ;
process response ;
*附加信息*
环境是x86 Windows XP.线程代码是一个长期的和涉及一系列与串行设备,但在一般的相互作用,它由写入字符到COM端口(使用AsyncFree串行库)并等待字符由驻留在传入字符缓冲器被返回的和他们到达时处理它们.我想这个串行库会让设备读写.只要在线程的时间可以是一分钟,或短则几秒钟,但大部分时间都花在等待字符离开港口,或等待响应字符(波特率为慢),因此我的问题是关于线程在等待时表现的最佳方式.目前我Sleep在循环中调用等待CharactersInBuffer变为非零,在它到达时处理每个字符,并在我有完整响应时退出线程.所以代码看起来更像(忽略超时处理等):
send command ;
Packet = '' ;
repeat
repeat
Sleep (20) ;
until response character arrived ;
build Packet
until complete packet arrived
process response ;
我制作了一个二十一点游戏,我希望AI玩家在拍卡之间暂停一下.我试过简单地使用Thread.sleep(x),但这会让它冻结,直到AI玩家完成所有的牌.我知道Swing不是线程安全的,所以我看了Timers,但我无法理解如何使用它.这是我目前的代码:
while (JB.total < 21) {
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
System.out.println("Oh noes!");
}
switch (getJBTable(JB.total, JB.aces > 0)) {
case 0:
JB.hit();
break;
case 1:
break done;
case 2:
JB.hit();
JB.bet *= 2;
break done;
}
}
BTW,hit(); 方法更新GUI.
Thread.Sleep(0)立即放弃线程的当前时间片,自愿将CPU交给其他线程.
我想测试这个,下面是我的测试代码:
static string s = "";
static void Main(string[] args)
{
//Create two threads that append string s
Thread threadPoints = new Thread(SetPoints);
Thread threadNewLines = new Thread(SetNewLines);
//Start threads
threadPoints.Start();
threadNewLines.Start();
//Wait one second for threads to manipulate string s
Thread.Sleep(1000);
//Threads have an infinite loop so we have to close them forcefully.
threadPoints.Abort();
threadNewLines.Abort();
//Print string s and wait for user-input
Console.WriteLine(s);
Console.ReadKey();
}
threadPoints和threadNewLines运行的函数:
static void SetPoints()
{
while(true)
{
s …为了同步/队列访问共享资源,我将使用信号量,在等待循环的帮助下.
为了不碰到CPU挂钩,我想sleep()在那个while循环中稍微进行一下.
我搜索了http://developer.android.com参考,发现了两个这样的sleep()函数,我很困惑哪个适合哪种情况:
哪一个更适合我描述的情况,为什么？
以下代码:
long msBefore = System.currentTimeMillis();
//Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
try
{Thread.sleep(200);
} catch (InterruptedException e){}
System.out.println("Time: " + (System.currentTimeMillis() - msBefore));
印刷品:
Time: 578
Time: 594
Time: 625
Time: 640
Time: 641
Time: 609
Time: 625
Time: 625
Time: 610
Time: 609
Time: 625
Time: 625
Time: 422
Time: 625
Time: 594
Time: 609
Time: 625
Time: 594
Time: 594
Time: 625
问题出在哪里？
这是一个控制台程序,希望10个线程批量启动,等待5秒,然后批量停止.
static void Main(string[] args)
{
System.Threading.Tasks.Parallel.For(0, 10, (index) =>
{
Action<int> act = (i) =>
{
Console.Write("start {0} ", i);
Thread.Sleep(5000);
};
act.BeginInvoke(index, OnTaskComplete, index);
});
Console.ReadKey();
}
static void OnTaskComplete(IAsyncResult res)
{
Console.Write("finish {0} ", res.AsyncState);
}
但结果不是我的预期,10个线程一个接一个地慢慢开始(大约1秒间隔),甚至一些"完成"在一些"开始"之前出现.
当注释掉Thread.Sleep时,所有线程都在flash中开始和结束.
会Thread.Sleep影响其他线程吗？无论如何要做一个纯粹的空闲时间？
/ - - - - - - - - - - - - - - -编辑 - - - - - - - - - - ----------
同样的问题也发生在:
static void Main(string[] args)
{
System.Threading.Tasks.Parallel.For(0, 10, (index) …基本上我试图使用JavaFX做一个简短的效果.我有一个心脏的形状(从两个圆圈和一个多边形加起来),我可以使用double值改变大小p."标准尺寸"将是p = 1.0;.
我试图给心脏增加一个泵效应.我有方法pumpOnce():
public void pumpOnce(){
p = p + 1;
initHeart();
//Here goes what ever it takes to make stuff working!!
p = p - 1;
initHeart();
}
initHeart()吸取内心的基础p.
我发现Thread.sleep();由于JavaFX中的线程原理,或类似的方法不起作用.
但是我可以用什么呢？
Thread.Sleep()分辨率从1到15.6ms不等
鉴于此控制台应用:
class Program
{
static void Main()
{
int outer = 100;
int inner = 100;
Stopwatch sw = new Stopwatch();
for (int j = 0; j < outer; j++)
{
int i;
sw.Restart();
for (i = 0; i < inner; i++)
Thread.Sleep(1);
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
}
}
}
我期望输出为100个数字接近100.相反,我得到这样的东西:
99 99 99 100 99 99 99 106 106 99 99 99 100 100 99 99 99 99 101 99 99 99 99 99 99 99 99 99 99 99 …
注意,这不是一个问题std::condition_variable::wait_for().我知道可以假装醒来.
我的程序的行为表明这个问题的答案是肯定的,但是对于condition_variable案例,STL文档非常清楚.至少在cppreference.com上,this_thread的正确答案似乎是否定的.
编译器是gcc 4.8.1,如果这是一个缺陷.
如何在 Godot 中暂停执行一段时间？我实在找不到明确的答案。