一位队友提出以下要求:
"
Thread.interrupt()本质上是破碎的,应该(几乎)永远不会被使用".
我试图理解为什么会这样.
它是一个永远不会使用的已知最佳实践Thread.interrupt()吗？你能提供证据证明它为何被破坏/错误,并且不应该用于编写强大的多线程代码吗？
注意 - 如果从设计防腐剂中"非常",我对这个问题不感兴趣.我的问题是 - 它有多少？
我是线程的新手.我怎样才能开始t.join工作,调用它的线程会等到t执行完毕？
这段代码只会冻结程序,因为线程正在等待自己死掉,对吧？
public static void main(String[] args) throws InterruptedException {
Thread t0 = new Thready();
t0.start();
}
@Override
public void run() {
for (String s : info) {
try {
join();
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("%s %s%n", getName(), s);
}
}
如果我想要有两个线程,我会怎么做,其中一个线程打印出一半的info数组,然后在完成剩下的工作之前等待另一个完成？
我有一个Java程序,它在一个单独的(非EDT)线程上执行紧密循环.虽然我认为Swing UI仍然应该响应,但事实并非如此.下面的示例程序显示了问题:单击"试用我"按钮应该在大约一半时间后弹出一个对话框,并且应该可以通过单击其任何响应立即关闭该对话框.相反,对话框需要更长的时间才能显示,并且/或者在单击其中一个按钮后需要很长时间才能关闭.
有没有人知道为什么EDT处理被延迟,即使只有一个繁忙的线程？
(请注意,尽管Thread.sleep呼叫的各种建议是导致问题的原因,但事实并非如此.它可以被移除,问题仍然可以重现,尽管它表现得稍微不那么频繁并且通常表现出上述第二种行为 - 即非- 响应JOptionPane对话而不是延迟对话框出现.此外,没有理由睡眠调用应该屈服于另一个线程,因为有如上所述的备用处理器核心 ; EDT可以在调用后继续在另一个核心上运行sleep).
import java.awt.EventQueue;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class MFrame extends JFrame
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
new MFrame();
});
}
public MFrame()
{
JButton tryme = new JButton("Try me!");
tryme.addActionListener((e) -> {
Thread t = new Thread(() -> {
int a = 4;
for (int i = 0; i …许多支持多线程的语言都提供了一个允许线程向其他线程提供上下文切换的操作.例如Haskell的yield.
但是,文档没有说明实际用例是什么.什么时候适合使用这些屈服函数,何时不适用？
最近我看到一个这样的用例再次提高Warp的性能,结果发现当网络服务器发送消息时,yield在尝试再次接收数据之前值得调用,因为它需要客户端一些时间来处理答案并发出另一个请求.
我想在调用时看到其他示例或指南yield带来一些好处.
我主要对Haskell感兴趣,但我不介意学习其他语言或概念.
注意:这与生成器或协同程序无关,例如yieldPython或Ruby.
Java 13引入了yield用于switch表达式的关键字。
我该如何使用它？它与默认值return或break值有什么区别？
我的代码:
String[] torrentFiles = new File("/root/torrents/").list();
if(torrentFiles.length == 0 || torrentFiles == null)
{
System.exit(0);
}
ex = Executors.newFixedThreadPool(3);
for(String torrentFile : torrentFiles)
{
ex.submit(new DownloadTorrent("/root/torrents/" + torrentFile));
}
ex.shutdown();
try
{
ex.awaitTermination(30, TimeUnit.MINUTES);
}
catch(InterruptedException ex1)
{
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex1);
}
但有时洪流下载需要未知的时间价值,« awaitTermination»不能按我的意愿工作.我需要在半小时后立即停止所有执行的线程,但据我所知« awaitTermination»只使用interrupt()仅在循环或等待中工作的方法.如果这一刻发生,超时不起作用.那么,怎么样？
我知道非阻塞 IO 不会阻塞调用线程，而是在等待 IO 时释放它来做其他事情。
我刚刚了解了Thread. yield允许线程告诉 CPU 运行其他线程的方法......技术上产生控制。
这两个东西，非阻塞 IO 和Thread. yield听起来和我很相似，所以我想知道，在最基本的层面上，非阻塞 IO 是Thread. yield在做 IO 时才使用的吗？
public class YieldDemo extends Thread{
public static void main(String[] args) {
YieldDemo y1 = new YieldDemo();
YieldDemo y2= new YieldDemo();
y1.start();
y2.start();
}
public void run() {
for(int i=0;i<=5;i++) {
if(i==3) {
Thread.yield();
} else
System.out.println(i+Thread.currentThread().toString());
}
}
}
根据yield()的文档,thread-1应该产生并允许thread-2在第3次循环之后进行处理.但是,输出并不像预期的那样.相同的线程继续跳过第3次迭代.在一个线程完成循环后,其他线程以相同的行为执行.请解释.
输出:
0Thread[Thread-1,5,main]
1Thread[Thread-1,5,main]
2Thread[Thread-1,5,main]
4Thread[Thread-1,5,main]
5Thread[Thread-1,5,main]
0Thread[Thread-0,5,main]
1Thread[Thread-0,5,main]
2Thread[Thread-0,5,main]
4Thread[Thread-0,5,main]
5Thread[Thread-0,5,main]