相关疑难解决方法(0)

Thread currentThread=Thread.currentThread();
        public void run()
        {               

             while(!shutdown)
            {                               
                try
                {
                    System.out.println(currentThread.isAlive());
                Thread.interrupted();

                System.out.println(currentThread.isAlive());
                if(currentThread.isAlive()==false)
                {
                    shutdown=true;
                }
                }
                catch(Exception e)
                {
                    currentThread.interrupt();
                }                   
            }
        }

    });
    thread.start();

我有以下代码:

renderThread = new Thread(new Runnable() {

    @Override
    public void run() {
        for (int i = 0; i < 10000000; i++) {
            System.out.println("Number: " + i);
        }
    }
});

renderThread.start();

try {
    Thread.sleep(100);
} catch (InterruptedException ex) {
    ex.printStackTrace();
}

renderThread.interrupt(); //It should stop, but it does not stop.

renderThread.interrupt()不会中断线程,它会继续运行.如果我更换renderThread.interrupt()用.stop(),那么线程停止.但是,.stop()已弃用.那么,什么是停止线程的正确方法,如果stop被弃用并且interrupt不起作用？

我有一个主线程,在该线程中我开始一个新线程.(子线程).该子线程打开服务器套接字并开始侦听连接.我希望该线程停止执行并关闭它初始化的任何内容(如Socket),当主线程从外部获取消息时(从那里得到消息不是关注点).我应该如何停止线程并关闭所有连接是我想要的.

我应该使用共享变量吗？这样当主线程收到消息时它应该修改它,子线程应该不断检查该共享变量的变化？

我该如何实施呢？一些有用的链接可能有帮助或示例代码？

我试过的内容如下:在主线程中我声明了一个变量

 flag=0;

当主线程收到消息时,它会设置

flag = 1 ;

并且线程监听更改,如下所示:

  void ()run{

       while(true){

            if(flag==1){
                   break;
              }

       sock1 = Ssocket.accept(); 
  }

但上面的代码根本不起作用.我该怎么办？

我想知道如何在 Java 中停止一个无响应的线程，这样它就真的死了。

首先，我很清楚Thread.stop()被弃用以及为什么不应该使用它；关于这个主题已经有很多很好的答案，参见。[1] [2]。因此，更准确的问题是，从技术上讲，是否真的有可能杀死一个代码不受我们控制但可能具有敌意且不响应中断的线程。

在最简单的情况下，一个恶意线程正在运行while(true);，但它也可能耗尽内存或其他系统资源来造成更大的破坏。调用interrupt()那个线程显然是无效的。打电话stop()呢？

我已经在调试器中运行了它，事实上，线程真的消失了。但这种方法可靠吗？可以为这种情况准备敌对线程；想想try{run();}catch(ThreadDeath t){run();}它在哪里捕获ThreadDeath我们调用时产生的stop()并再次递归调用自身。

作为外部观察者，我们无法看到正在发生的事情；Thread.stop()总是默默地运行。最糟糕的是，通常的诊断将不再起作用（在 Corretto 1.8.0_275 Windows x64 上调试时试过这个）：无论是否成功杀死线程，Thread.getState()总是返回RUNNABLE，同样适用Thread.isAlive()（总是如此）。

我开发了一个应用程序，因为我有视图寻呼机来显示不同的视频图像，有n个寻呼机屏幕，

所有页面都是自动滑动的，如下所示。

 public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    ViewGroup v=(ViewGroup)inflater.inflate(R.layout.fragment_home, container, false);

    ButterKnife.bind(this, v);



    /*Snackbar.make(v, "Home Fragment", Snackbar.LENGTH_LONG)
            .setAction("Action", null).show();*/
    //Toast.makeText(getActivity(),"home Fragment",Toast.LENGTH_LONG).show();
    viewPager.setAdapter(new MyPagerAdapter());

    t=new Thread(){
        @Override
        public void run()
        {

            try {
                while(true) {
                    count %= size;
                    Log.w("slide", "" + count);
                    getActivity().runOnUiThread(new Runnable() {

                        @Override
                        public void run() {
                            viewPager.setCurrentItem(count);
                        }
                    });

                    count++;
                    Thread.currentThread().sleep(5000);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    //t.start();

    return v;
}

当我触摸这个特定的寻呼机时，我想停止自动滑动寻呼机，当我将手指从寻呼机上移开时，寻呼机的自动滑动开始并再次触摸时停止，如何实现此功能？

我有一个启动几个线程的应用程序，最终一个线程可能需要退出整个应用程序，但是其他线程可能处于任务中间，所以我想让它们在退出之前继续当前循环。

在下面的示例中，线程 2 不知道线程 1 何时尝试退出，它只是强制一切立即完成。

我怎样才能让 Thread2、3 和 4 等在关闭之前完成它们的循环？

编辑：为了解决重复的问题：这与父类不能负责操纵关闭的典型情况不同，任何单个线程都必须能够启动关闭。

Edit2：我还留下了我最终做的答案，这是已接受答案的实现。

class Scratch {
    public static void main(String[] args) {
        Thread Task1 = new Thread(new Task1());
        Task1.start();

        Thread Task2 = new Thread(new Task2());
        Task2.start();

        // ... more threads
    }

    public class Task1 implements Runnable {
        public void run() {
            while (true) {
                // ...
                System.exit(0);
                // ...
            }
        }
    }

    public class Task2 implements Runnable {
        public void run() {
            while (true) {
                // ...
                // …

如何杀死线程？.....如何在多线程中重新启动它们？

在我的应用程序中，我有一个按钮，当单击它时，我启动一个新线程并更改按钮的文本。如果再次按下按钮，它将开始更快地更改其文本。

我想在第二次按下按钮时中断线程。正确的方法是什么？

public class TestActivity extends Activity {

 Button btn;
 int i = 0;

 @Override
 public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
     btn = (Button)findViewById(R.id.btn);
     btn.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View v) {
           runThread();
       }
     });
 }

private void runThread() {
    new Thread() {
      public void run() {
          while (i++ < 1000) {
              try {
                  runOnUiThread(new Runnable() {

                      @Override
                      public void run() {
                          btn.setText("#" + i);
                      }
                  });
                  Thread.sleep(300);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
    }.start(); …

所以我目前正在参加这个演讲。在 28:50 分钟，做出以下声明：“在硬件上，它可能位于主内存中、多个三级缓存中、四个二级缓存中 [...] 这不是你的问题。这就是硬件设计人员的问题。”

然而，在 Java 中，我们必须将停止线程的布尔值声明为 volatile，因为当另一个线程调用 stop 方法时，不能保证正在运行的线程会知道此更改。

为什么会出现这种情况，硬件级别应该负责用正确的值更新每个缓存？

我确定我在这里遗漏了一些东西。

有问题的代码：

public class App {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        worker.signalStop();
        System.out.println(worker.isShouldStop());
        System.out.println(worker.getVal());
        System.out.println(worker.getVal());
    }

    static class Worker extends Thread {
        private /*volatile*/ boolean shouldStop = false;
        private long val = 0;

        @Override
        public void run() {
            while (!shouldStop) {
                val++;
            }
            System.out.println("Stopped");
        }

        public void signalStop() { …

如果我有以下结构,有人可以告诉我如何停止线程？

我想停止线程乙到期线程后Ç.

    c = new c();
    c.start();
    b = new b();
    b.start();

class c extends Thread {

    @Override
    public void run() {
      // DRAW IMAGE
      // b.stop(); - doenst work
    }
}

class b extends Thread {

    @Override
    public void run() {
      // PROGRESS BAR

    }
}

我试图中断正常运行的线程（未处于 sleep() 或 wait() 状态）。

在网络中浏览时，我知道中断正常运行的线程只会将标志设置为 true 并继续该过程。

代码片段是

one.java

......
......
actionperformedmethod {

if (actionCmd.equals("cancel")) {
    try {
        r1.stop();  // to two.java
    } catch (InterruptedException ex) {
        ....
        ....
    }
}
}

在two.java

.....
.....
stop method() throws InterruptedException{
        if(!(t.isInterrupted())){
            t.interrupt();
            throw new InterruptedException();
        }
}

从 Two.java 当我抛出 InterruptedException 时，我可以在 one.java 处获取异常块，但是之后如何停止线程，因为即使在该线程似乎继续正常过程之后。

我对线程概念不熟悉，请帮忙..

如果这个问题听起来很冒昧,我会提前道歉.我对此很新.所以这就是它...

我一直在研究"java线程停止"问题.我在stackoverflow上阅读了很多文章,他们中的大多数都得出结论,在java中线程停止非常尴尬.一些好方法包括:

1. 使用join(这个答案有87个upvotes)并等到线程结束.
2. 设置一个volatile标志以表示其他线程.这个答案得到了113个赞成票
3. 很多人推荐Thread.interrupt()并稍后检查 isInterrupted
4. 有些人建议使用像ExecutorService这样的高级API.但是该shutdownNow方法没有给出任何保证,并且依赖于该isInterrupted布尔值

但是上述两种方法都不允许立即停止线程.例如,如果程序正在运行某些程序SQL 并等待外部数据库响应,则上述所有方法都将"谦虚地等待",直到SQL完成为止.所以停止不是立竿见影的.只有SQL完成(可能需要数小时),程序才会检查isInterrupted或其他标志,然后停止

这是一个妙语... 我知道Eclipse是java根据这个 stackoverflow的答案编写的.每当我点击红色停止按钮时,Eclipse将立即停止我的应用程序.我认为它不使用,Thread.stop因为它已被弃用.但我无法使用stackoverflow上推荐的那些方法.Eclipse如何设法如此快速地停止线程？