Java RequestProcessor.create方法代碼示例

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
private JMenu createMenu(BaseKit kit, int line, boolean backgroundInit){
    final DelayedMenu pm = new DelayedMenu(NbBundle.getBundle(BaseKit.class).getString("generate-gutter-popup"));
    final BaseKit fKit = kit;
    final int fLine = line;

    if (backgroundInit){
        RequestProcessor rp = RequestProcessor.getDefault();
        RequestProcessor.Task task = rp.create(new Runnable(){
            public void run(){
                initMenu(pm, fKit, fLine);
                pm.clearTask(); // clear the finished task reference to avoid leaking
            }
        });
        pm.setTask(task); // set before task execution so that always cleaned properly
        task.schedule(0);
    }else{
        initMenu(pm, fKit, fLine);
    }

    return pm;
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
/** Creates new form ProjectChooserAccessory */
public ProjectChooserAccessory(JFileChooser chooser, boolean isOpenSubprojects) {
    initComponents();

    modelUpdater = new ModelUpdater();
    //#98080
    RP = new RequestProcessor(ModelUpdater.class.getName(), 1);
    RP2 = new RequestProcessor(ModelUpdater.class.getName(), 1);
    updateSubprojectsTask = RP.create(modelUpdater);
    updateSubprojectsTask.setPriority( Thread.MIN_PRIORITY );

    // Listen on the subproject checkbox to change the option accordingly
    jCheckBoxSubprojects.setSelected( isOpenSubprojects );
    jCheckBoxSubprojects.addActionListener( this );

    // Listen on the chooser to update the Accessory
    chooser.addPropertyChangeListener( this );

    // Set default list model for the subprojects list
    jListSubprojects.setModel( new DefaultListModel() );

    // Disable the Accessory. JFileChooser does not select a file
    // by default
    setAccessoryEnablement( false, 0 );
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testStopAndSchedule() throws Exception {
    final boolean executed[] = { false };
    class R implements Runnable {
        @Override
        public void run() {
            executed[0] = true;
        }
    }
    
    RequestProcessor rp = new RequestProcessor("stopped");
    RequestProcessor.Task task = rp.create(new R());
    assertTrue("No runnables", rp.shutdownNow().isEmpty());
    task.schedule(0);
    task.waitFinished(500);
    assertFalse("Not executed at all", executed[0]);
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
private void doCheckFinished(boolean usefalse) {
        RequestProcessor rp = new RequestProcessor ("Finish");

class R extends Object implements Runnable {
    RequestProcessor.Task t;
    
    public void run () {
        if (t.isFinished ()) {
            fail ("Finished when running");
        }
    }
}
        
        R r = new R ();
        RequestProcessor.Task task = usefalse ? rp.create(r, false) : rp.create (r);
        r.t = task;

        if (task.isFinished ()) {
            fail ("Finished after creation");
        }
     
        doCommonTestWithScheduling(task);
    }
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testCheckFinishedWithTrue () {
    RequestProcessor rp = new RequestProcessor ("Finish");
    
    class R extends Object implements Runnable {
        RequestProcessor.Task t;
        
        public void run () {
            if (t.isFinished ()) {
                fail ("Finished when running");
            }
        }
    }
    
    R r = new R ();
    RequestProcessor.Task task = rp.create(r, true);
    r.t = task;

    assertTrue("It has to be finished after creation", task.isFinished());

    task.waitFinished();

    // rest is the same
    doCommonTestWithScheduling(task);
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
private RequestProcessor.Task createTask() {
    RequestProcessor rp = null;
    try {
        Session s = (Session) debugger.getClass().getMethod("getSession").invoke(debugger);
        rp = s.lookupFirst(null, RequestProcessor.class);
    } catch (Exception e) {
        Exceptions.printStackTrace(e);
    }
    if (rp == null) {
        rp = RequestProcessor.getDefault();
    }
    RequestProcessor.Task task = rp.create(new RefreshTree());
    return task;
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
private HudsonInstanceImpl(HudsonInstanceProperties properties, boolean interactive, BuilderConnector builderConnector, Persistence persistence) {
    this.builderConnector = builderConnector;
    this.properties = properties;
    this.persistence = persistence != null ? persistence : Persistence.persistent();

    RP = new RequestProcessor(getUrl(), 1, true);
    final AtomicBoolean firstSynch = new AtomicBoolean(interactive); // #200643
    synchronization = RP.create(new Runnable() {
        private boolean firstRun = true;

        @Override
        public void run() {
            String s = getProperties().get(INSTANCE_SYNC);
            int pause = Integer.parseInt(s) * 60 * 1000;
            if (pause > 0 || firstSynch.compareAndSet(true, false)) {
                doSynchronize(false, firstRun);
                firstRun = false;
            }
            if (pause > 0) {
                synchronization.schedule(pause);
            }
        }
    });
    synchronization.schedule(0);
    this.properties.addPropertyChangeListener(new PropertyChangeListener() {
        @Override public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getPropertyName().equals(INSTANCE_SYNC)) {
                synchronization.schedule(0);
            }
        }
    });
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
private NotificationsManager () {
    files = new HashSet<File>();
    rp = new RequestProcessor("SubversionNotifications", 1, true);  //NOI18N
    notificationTask = rp.create(new NotificationTask());
    cache = Subversion.getInstance().getStatusCache();
    kenaiAccessor = SvnKenaiAccessor.getInstance();
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
DocumentModel(Document doc, DocumentModelProvider provider) throws DocumentModelException {
    this.doc = (BaseDocument)doc; //type changed in DocumentModel.getDocumentModel(document);
    this.provider = provider;
    
    //init RP & RP task
    requestProcessor = new RequestProcessor(DocumentModel.class.getName());
    task = requestProcessor.create(new Runnable() {
        public void run() {
            updateModel();
        }
    });
    
    //create a new root element - this element comprises the entire document
    addRootElement();
    
    /*create a sorted set which sorts its elements according to their
    startoffsets and endoffsets.
    - lets have elements E1 and E2:
     
    if E1.startOffset > E2.startOffset then the E1 is before E2.
    if E1.startOffset == E2.startOffset then
       if E1.endOffset > E2.endOffset then the E1 is before E2
     */
    initDocumentModel();
    
    this.changesWatcher = new DocumentChangesWatcher();
    getDocument().addDocumentListener(WeakListeners.document(changesWatcher, doc));
    
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
@Override
protected void performAction(final Node[] activatedNodes) {
    final Collection<? extends TestMethodDebuggerProvider> providers = Lookup.getDefault().lookupAll(TestMethodDebuggerProvider.class);
    RequestProcessor RP = new RequestProcessor("TestMethodDebuggerAction", 1, true);   // NOI18N
    debugMethodTask = RP.create(new Runnable() {
        @Override
        public void run() {
            for (TestMethodDebuggerProvider provider : providers) {
                if (provider.canHandle(activatedNodes[0])) {
                    debugMethodProvider = provider;
                    break;
                }
            }
        }
    });
    final ProgressHandle ph = ProgressHandleFactory.createHandle(Bundle.Search_For_Provider(), debugMethodTask);
    debugMethodTask.addTaskListener(new TaskListener() {
        @Override
        public void taskFinished(org.openide.util.Task task) {
            ph.finish();
            if (debugMethodProvider == null) {
                StatusDisplayer.getDefault().setStatusText(Bundle.No_Provider_Found());
            } else {
                debugMethodProvider.debugTestMethod(activatedNodes[0]);
            }
        }
    });
    ph.start();
    debugMethodTask.schedule(0);
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testUseAsInCND() throws Exception {
    final RequestProcessor processor = new RequestProcessor("testUseAsInCND");
    final AtomicReference<String> threadName = new AtomicReference<String>();
    final Runnable task = new Runnable() {
        @Override
        public void run() {
            threadName.set(Thread.currentThread().getName());
        }
    };
    final String taskName = "MyTask";
    final RequestProcessor.Task rpTask = processor.create(new Runnable() {
        @Override
        public void run() {
            String oldName = Thread.currentThread().getName();
            Thread.currentThread().setName(taskName);
            try {
                task.run();
            } finally {
                Thread.currentThread().setName(oldName);
            }
        }
    });
    processor.post(rpTask);
    rpTask.waitFinished();
    
    assertEquals("Executed and named OK", taskName, threadName.get());
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testTheCancelOfNonStartedTask() {
    Counter x = new Counter ();
    RequestProcessor rp = new RequestProcessor ("testTheCancelOfNonStartedTask");
    final RequestProcessor.Task task = rp.create (x);
    assertFalse("Not started tasks cannot be cancelled", task.cancel());
    assertFalse("But not finished", task.isFinished());
    assertFalse("Can be cancelled only once", task.cancel());
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testTheCancelOfFutureTask() {
    Counter x = new Counter ();
    RequestProcessor rp = new RequestProcessor ("testTheCancelOfFutureTask");
    final RequestProcessor.Task task = rp.create (x);
    task.schedule(20000);
    assertTrue("Sure, that one can be cancelled", task.cancel());
    assertTrue("After cancle we are finished", task.isFinished());
    assertFalse("Can be cancelled only once", task.cancel());
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testWhenWaitingForALimitedTimeFromTheSameProcessorThenInterruptedExceptionIsThrownImmediatelly () throws Exception {
    Counter x = new Counter ();
    RequestProcessor rp = new RequestProcessor ("testWaitFinishedOnNotStartedTaskFromRPThread");
    final RequestProcessor.Task task = rp.create (x);
    
    class WaitTask implements Runnable {
        public boolean finished;
        
        public synchronized void run () {
            long time = System.currentTimeMillis ();
            try {
                task.waitFinished (1000);
                fail ("This should throw an exception. Btw time was: " + (System.currentTimeMillis () - time));
            } catch (InterruptedException ex) {
                // ok, this is expected
            } finally {
                time = System.currentTimeMillis () - time;
                notifyAll ();
            }
            if (time > 100) {
                fail ("Exception should be thrown quickly. Was: " + time);
            }
            finished = true;
        }
        
    }
    WaitTask wt = new WaitTask ();
    synchronized (wt) {
        rp.post (wt);
        wt.wait ();
    }
    assertTrue ("The task.waitFinished has to finish", wt.finished);
    x.assertCnt ("The task has NOT been executed", 0);
}
 

import org.openide.util.RequestProcessor; //導入方法依賴的package包/類
public void testRunOutOfMemory() throws Exception {
    RequestProcessor rp = new RequestProcessor("testRunOutOfMemory", 1, false, false);
    final int[] cnt = { 0 };
    RequestProcessor.Task task = rp.create(new Runnable() {
        @Override
        public void run() {
            cnt[0]++;
        }
    });
    for (int i = 0; i < 10000000; i++) {
        task.schedule(2000000);
    }
    assertEquals("Still zero", 0, cnt[0]);
}