当我重新启动twitterStream时，为什么java.util.concurrent.RejectedExecutionException使用Twitter4J对tweet进行采样？

在下面的java应用程序中，我使用示例函数使用TwitterStream收集推文。我需要在用户需要时启动和停止流，但我得到以下异常：

java.util.concurrent.RejectedExecutionException: Task twitter4j.StatusStreamBase$1@74e75335 rejected from java.util.concurrent.ThreadPoolExecutor@5117b235[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 2]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
    at twitter4j.DispatcherImpl.invokeLater(DispatcherImpl.java:58)
    at twitter4j.StatusStreamBase.handleNextElement(StatusStreamBase.java:80)
    at twitter4j.StatusStreamImpl.next(StatusStreamImpl.java:56)
    at twitter4j.TwitterStreamImpl$TwitterStreamConsumer.run(TwitterStreamImpl.java:568)

当用户按下“爬网”或“停止爬网”时，将正确调用ActionExecuted方法。但是，如果用户按下爬网，然后按下停止，然后再次按下爬网，我会得到上面的错误

我有几门课，但主要的有：

第一个创建接口并与crawler类通信

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;

public class StackOv extends JFrame implements ActionListener{

    private JTextArea usersSaved;
    private boolean alreadyCrawling;
    private boolean stopReceived;
    private Stream stream;
    private JButton Crawl;
    private JButton stopCrawl;
    private Mongo m;

    public StackOv(){
        this.stopReceived = false;
        this.alreadyCrawling = false;
        setLayout(new FlowLayout(FlowLayout.CENTER));
        Crawl = new JButton("Crawl");
        Crawl.setActionCommand("Crawl");
        Crawl.addActionListener(this);
        stopCrawl = new JButton("Stop Crawling");
        stopCrawl.setActionCommand("Stop Crawling");
        stopCrawl.addActionListener(this);
        m = new Mongo(); //instance of class that uses MongoDB
       /*
       *
       *bla bla bla create the rest of the interface as you wish
       *add(button)
       *add(button)
       *etc...
       */

    }


    public void setOut(String out){
        usersSaved.setText(out);
    }

    public void setOffAlreadyCrawling(){
        this.alreadyCrawling = false;
    }
    @Override
    public void actionPerformed(ActionEvent e){
        if(e.getActionCommand().equals("Stop Crawling") && !this.stopReceived){
            this.stopReceived = true;
            stream.setStop();
        }
        else if(e.getActionCommand().equals("Crawl") && !alreadyCrawling){
            if(stream != null && stream.isAlive()){
                stream.interrupt();
            }
            alreadyCrawling = true;
            stream = new Stream(m, this);
            //independently of using one of the following two calls, I get the same exception above
            stream.execute1();
            //stream.start();
            this.stopReceived = false;
        }
    }

    public void main(String[] args){
        StackOv so = new StackOv();
        so.setSize(800, 800);
        so.setVisible(true);
    }

}

下面的类是crawler类，当stopCrawl为true或twitterStream采样的tweet数超过最大限制时关闭twitterStream

import java.awt.TextArea;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JTextArea;
import javax.swing.JTextField;

import twitter4j.FilterQuery;
import twitter4j.StallWarning;
import twitter4j.Status;
import twitter4j.StatusDeletionNotice;
import twitter4j.StatusListener;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.TwitterStream;
import twitter4j.TwitterStreamFactory;

public class Stream extends Thread{

    private Crawler cr;
    private TwitterStream twitterStream;
    private int maxTweets;
    private int usersSaved;
    private Mongo database;
    private CreateIndex ci;
    private TwitterSearch twitterSearch;
    private static boolean stopCrawl;

    public Stream(Mongo database, TwitterSearch twitterSearch){

        Stream.stopCrawl = false;
        this.database = database;
        this.cr = new Crawler(database);
        this.twitterStream = new TwitterStreamFactory(DefaultConfiguration.getConfiguration()).getInstance();
        this.maxTweets = 1000;
        ci = new CreateIndex(database);
        this.twitterSearch = twitterSearch;


    }

    public void setStop(){
        Stream.stopCrawl = true;
    }

    public void execute() throws TwitterException {

        final List<Status> statuses = new ArrayList<Status>();

        StatusListener listener = new StatusListener() {

            public void onStatus(Status status) {
                statuses.add(status);
                System.out.println(statuses.size() + ":" + status.getText());
                int usersIndexed = cr.retrieve(status.getUser());
                usersSaved = database.countDocuments();
                twitterSearch.setOut("usersSaved: "+usersSaved);
                if(usersIndexed > maxTweets || Stream.stopCrawl){
                    //ci.load();
                    ci.load(); //this call creates my index
                    twitterSearch.setOut("INDEX CREATED");
                    System.out.println("shutdown...");
                    twitterSearch.setOffAlreadyCrawling();
                    twitterStream.shutdown();
                }
            }

            public void onDeletionNotice(StatusDeletionNotice statusDeletionNotice) {

            }

            public void onTrackLimitationNotice(int numberOfLimitedStatuses) {

            }

            public void onScrubGeo(long userId, long upToStatusId) {

            }

            public void onException(Exception ex) {
                ex.printStackTrace();
            }
            @Override
            public void onStallWarning(StallWarning arg0) {
                // TODO Auto-generated method stub

            }

        };


        twitterStream.addListener(listener);
        twitterStream.sample("en");
    }

    public void execute1(){
        try{
            this.execute();
        }catch(TwitterException e){
            e.printStackTrace();
        }
    }

    public void run(){
        try {
            this.execute();
        } catch (TwitterException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

import java.awt.TextArea；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.JTextArea；
导入javax.swing.JTextField；
导入twitter4j.FilterQuery；
导入twitter4j.StallWarning；
导入twitter4j.状态；
导入twitter4j.StatusDeletionNotice；
导入twitter4j.StatusListener；
导入twitter4j.Twitter；
导入twitter4j.TwitterException；
导入twitter4j.TwitterFactory；
导入twitter4j.TwitterStream；
导入twitter4j.TwitterStreamFactory；
公共类流扩展线程{
私有爬虫；
私人推特流推特流；
私人互联网；
私有int用户保存；
私有Mongo数据库；
私有索引ci；
私人推特搜索推特搜索；
私有静态布尔停止爬网；
公共流（Mongo数据库、TwitterSearch、TwitterSearch）{
Stream.stopCrawl=false；
this.database=数据库；
this.cr=新爬虫（数据库）；
this.twitterStream=新的TwitterStreamFactory（DefaultConfiguration.getConfiguration（））.getInstance（）；
this.maxteets=1000；
ci=新的CreateIndex（数据库）；
this.twitterSearch=twitterSearch；
}
公共无效设置停止（）{
Stream.stopCrawl=true；
}
public void execute（）引发TwitterException{
最终列表状态=新建ArrayList（）；
StatusListener=新建StatusListener（）{
公共无效状态（状态）{
状态。添加（状态）；
System.out.println（statuses.size（）+“：“+status.getText（））；
int usersIndexed=cr.retrieve（status.getUser（））；
usersSaved=database.countDocuments（）；
设置（“usersSaved:+usersSaved”）；
if（usersIndexed>maxteets | | Stream.stopCrawl）{
//ci.load（）；
ci.load（）；//此调用创建我的索引
twitterSearch.setOut（“创建索引”）；
System.out.println（“关机…”）；
setOffFalReadyCrawling（）；
twitterStream.shutdown（）；
}
}
删除通知的公共作废（状态删除通知状态删除通知）{
}
公开无效onTrackLimitationNotice（int NumberOfLimitedStatus）{
}
onScrubGeo上的公共无效（长用户ID、长状态ID）{
}
公共无效OneException（例外情况除外）{
例如printStackTrace（）；
}
@凌驾
安装警告上的公共无效（安装警告arg0）{
//TODO自动生成的方法存根
}
};
twitterStream.addListener（listener）；
twitterStream.sample（“en”）；
}
public void execute1（）{
试一试{
这是execute（）；
}捕获（twitter异常）{
e、 printStackTrace（）；
}
}
公开募捐{
试一试{
这是execute（）；
}捕获（twitter异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}

当线程关闭/关闭时，它会阻止它像其他java IO类一样“重新启动”。换句话说，一旦你关闭它，你就不能再启动它了。我很确定在Twitter代码或您的代码中，您的线程正在停止。为了防止这种情况发生，下面是一段可能有效的代码片段：

---

另外，试试这个堆栈溢出的东西：。

请在答案中添加代码，最好在这里有代码，而不是外部站点。我自己以一种奇怪的方式解决了这个问题，我不知道如何解释……现在我将面临其他问题。当我有时间的时候，我会评估你的答案，然后决定是否选择它作为最佳答案。我很抱歉