java.util.Timer Java Examples

/**
 * 发送验证码
 * 
 * @param phone
 *            the phone
 */
private void sendVerifyCode(final String phone) {
	String CaptchaCode = etInputCaptchaCode_farget.getText().toString();
	dialog.show();
	btnReGetCode.setEnabled(false);
	btnReGetCode.setBackgroundResource(R.drawable.button_gray_short);
	secondleft = 60;
	timer = new Timer();
	timer.schedule(new TimerTask() {

		@Override
		public void run() {
			// 倒计时通知
			handler.sendEmptyMessage(handler_key.TICK_TIME.ordinal());
		}
	}, 1000, 1000);
	// 发送请求验证码指令
	// mCenter.cRequestSendVerifyCode(phone);
	// 发送请求验证码指令
	Log.i("AppTest", tokenString + ", " + captchaidString + ", " + CaptchaCode + ", " + phone);
	mCenter.cRequestSendVerifyCode(tokenString, captchaidString, CaptchaCode, phone);
}
 

void scheduleNow(Timer timer, TimerTask task, int how) {
    switch (how) {
        case 0 :
            timer.schedule(task, new Date(), Long.MAX_VALUE);
            break;
        case 1:
            timer.schedule(task, 0L, Long.MAX_VALUE);
            break;
        case 2:
            timer.scheduleAtFixedRate(task, new Date(), Long.MAX_VALUE);
            break;
        case 3:
            timer.scheduleAtFixedRate(task, 0L, Long.MAX_VALUE);
            break;
        default:
            fail(String.valueOf(how));
    }
}
 

private void startSubmitting() {
    // We use a timer cause want to be independent from the server tps
    final Timer timer = new Timer(true);
    timer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            // Plugin was disabled, e.g. because of a reload (is this even possible in Sponge?)
            if (!Sponge.getPluginManager().isLoaded(plugin.plugin.getId())) {
                timer.cancel();
                return;
            }
            // The data collection (e.g. for custom graphs) is done sync
            // Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
            Scheduler scheduler = Sponge.getScheduler();
            Task.Builder taskBuilder = scheduler.createTaskBuilder();
            taskBuilder.execute(() -> submitData()).submit(plugin);
        }
    }, 1000*60*5, 1000*60*30);
    // Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
    // WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
    // WARNING: Just don't do it!
}
 

public void doInit() throws ServletException {
    synchronized(s_initialized) {
        if ( !s_initialized ) {
            super.doInit();
            
            // Initialize the core service
            initCoreService();
            
            // Initialize the data service
            initDataService();
            
            // Initialize resources from other plugins
            initDynamicResources();
            
            // Schedule the timer task to run every 30 seconds
            IStatisticsProvider provider = ProviderFactory.getStatisticsProvider();
            if ( provider != null ) {
                s_statsTimer = new Timer(true);
                s_statsTimer.schedule(s_statsTimerTask, STATS_TIMER_INTERVAL, STATS_TIMER_INTERVAL);
            }
            
            s_initialized = true;
            DAS_LOGGER.getLogger().fine("DasServlet initialized."); // $NON-NLS-1$
        }
    }
}
 

public static void executeJobExecutorForTime(ProcessEngineConfiguration processEngineConfiguration, long maxMillisToWait, long intervalMillis) {
  AsyncExecutor asyncExecutor = processEngineConfiguration.getAsyncExecutor();
  asyncExecutor.start();

  try {
    Timer timer = new Timer();
    InteruptTask task = new InteruptTask(Thread.currentThread());
    timer.schedule(task, maxMillisToWait);
    try {
      while (!task.isTimeLimitExceeded()) {
        Thread.sleep(intervalMillis);
      }
    } catch (InterruptedException e) {
      // ignore
    } finally {
      timer.cancel();
    }

  } finally {
    asyncExecutor.shutdown();
  }
}
 

public static void main(String []s)
{
    final Dialog fd = new Dialog(new Frame(), true);
    Timer t = new Timer();
    t.schedule(new TimerTask() {

        public void run() {
            System.out.println("RUNNING TASK");
            fd.setVisible(false);
            fd.dispose();
            System.out.println("FINISHING TASK");
        }
    }, 3000L);

    fd.setVisible(true);
    t.cancel();
    Util.waitForIdle(null);

    AbstractTest.pass();
}
 

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

	final AsyncContext asyncContext = req.startAsync();

	// DON'T TRY THIS AT HOME: Working with threads in a Container !!
	new Timer().schedule(new TimerTask() {
		@Override
		public void run() {
			try {
				asyncContext.getResponse().getWriter().println(new Date() + ": Asynchronous Response");
				System.out.println("Release pending HTTP connection");
				asyncContext.complete();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}, 10 * 1000);
	resp.getWriter().println(new Date() + ": Async Servlet returns leaving the connection open");
}
 

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    storageTimer = new Timer();
    secondatyStorageTimer = new Timer();
    usbStorageTimer = new Timer();
    processTimer = new Timer();
    storageStats = (HomeItem) view.findViewById(R.id.storage_stats);
    secondayStorageStats = (HomeItem) view.findViewById(R.id.seconday_storage_stats);
    usbStorageStats = (HomeItem) view.findViewById(R.id.usb_storage_stats);
    memoryStats = (HomeItem) view.findViewById(R.id.memory_stats);
    recents = (TextView)view.findViewById(R.id.recents);
    recents_container = view.findViewById(R.id.recents_container);

    mShortcutsRecycler = (RecyclerView) view.findViewById(R.id.shortcuts_recycler);
    mRecentsRecycler = (RecyclerView) view.findViewById(R.id.recents_recycler);

    roots = DocumentsApplication.getRootsCache(getActivity());
    mHomeRoot = roots.getHomeRoot();
    showRecents();
    showData();
}
 

public static void main(String []s)
{
    final Dialog fd = new Dialog(new Frame(), true);
    Timer t = new Timer();
    t.schedule(new TimerTask() {

        public void run() {
            System.out.println("RUNNING TASK");
            fd.setVisible(false);
            fd.dispose();
            System.out.println("FINISHING TASK");
        }
    }, 3000L);

    fd.setVisible(true);
    t.cancel();
    Util.waitForIdle(null);

    AbstractTest.pass();
}
 

@Test
public void testMem() throws InterruptedException
{
	Timer timer = new Timer();
	
	MEMTimerTask task = new MEMTimerTask(
		new DataRefreshListener<Long[]>(){

			@Override
			public void onRefresh(long time, Long[] data) {
				System.out.println(data[0] + "/" + data[1] + "/" + data[2]+ "/" + data[3]);
			}});

	timer.schedule(task, 0, 1000);
	Thread.sleep(10000);
}
 

@Override
public void startCountDown() {
    countDownTimer = new Timer();
    countDownTimer.schedule(new TimerTask() {
        private int i = 0;

        @Override
        public void run() {
            if (++i > 10) {
                stopCountDown();
                mHandler.sendEmptyMessage(NaviSetLineActivity.MSG_START_NAV);
            } else {
                Message msg = new Message();
                msg.what = NaviSetLineActivity.MSG_UPDATE_COUNTDOWN;
                msg.arg1 = 10 - i;
                mHandler.sendMessage(msg);
            }
        }
    }, 1000, 1000);
}
 

CaptureReadHandler(String identifier, CaptureReadCompletionHandler result, int timeout, @Nullable CaptureReadCompletionHandler.TimeoutAction timeoutAction, boolean isNotifyOmitted) {
    mIdentifier = identifier;
    mResult = result;
    mIsNotifyOmitted = isNotifyOmitted;

    // Setup timeout if not zero
    if (timeout > 0 && timeoutAction != null) {
        mTimeoutAction = timeoutAction;

        mTimeoutTimer = new Timer();
        if (kProfileTimeouts) {
            mTimeoutStartingMillis = System.currentTimeMillis();
            Log.d(TAG, "Start timeout:  " + identifier + ". millis:" + mTimeoutStartingMillis);
        }
        mTimeoutTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                if (kProfileTimeouts) {
                    Log.d(TAG, "Fire timeout:   " + identifier + ". elapsed millis:" + (System.currentTimeMillis() - mTimeoutStartingMillis));
                }
                mResult.read(kPeripheralReadTimeoutError, null);
                mTimeoutAction.execute(identifier);
            }
        }, timeout);
    }
}
 

public static void main(String []s)
{
    final Dialog fd = new Dialog(new Frame(), true);
    Timer t = new Timer();
    t.schedule(new TimerTask() {

        public void run() {
            System.out.println("RUNNING TASK");
            fd.setVisible(false);
            fd.dispose();
            System.out.println("FINISHING TASK");
        }
    }, 3000L);

    fd.setVisible(true);
    t.cancel();
    Util.waitForIdle(null);

    AbstractTest.pass();
}
 

public static void main(String []s)
{
    final Dialog fd = new Dialog(new Frame(), true);
    Timer t = new Timer();
    t.schedule(new TimerTask() {

        public void run() {
            System.out.println("RUNNING TASK");
            fd.setVisible(false);
            fd.dispose();
            System.out.println("FINISHING TASK");
        }
    }, 3000L);

    fd.setVisible(true);
    t.cancel();
    Util.waitForIdle(null);

    AbstractTest.pass();
}
 

public void toFront() {
    try {
        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Platform.runLater(() -> {
                    getMyStage().toFront();
                    if (topCheck != null) {
                        topCheck.setSelected(AppVariables.getUserConfigBoolean(baseName + "Top", true));
                        if (topCheck.isVisible()) {
                            getMyStage().setAlwaysOnTop(topCheck.isSelected());
                        }
                    }
                    timer = null;
                });
            }
        }, 1000);
    } catch (Exception e) {
        logger.error(e.toString());
    }
}
 

public static void main(String []s)
{
    final Dialog fd = new Dialog(new Frame(), true);
    Timer t = new Timer();
    t.schedule(new TimerTask() {

        public void run() {
            System.out.println("RUNNING TASK");
            fd.setVisible(false);
            fd.dispose();
            System.out.println("FINISHING TASK");
        }
    }, 3000L);

    fd.setVisible(true);
    t.cancel();
    Util.waitForIdle(null);

    AbstractTest.pass();
}
 

void scheduleNow(Timer timer, TimerTask task, int how) {
    switch (how) {
        case 0 :
            timer.schedule(task, new Date(), Long.MAX_VALUE);
            break;
        case 1:
            timer.schedule(task, 0L, Long.MAX_VALUE);
            break;
        case 2:
            timer.scheduleAtFixedRate(task, new Date(), Long.MAX_VALUE);
            break;
        case 3:
            timer.scheduleAtFixedRate(task, 0L, Long.MAX_VALUE);
            break;
        default:
            fail(String.valueOf(how));
    }
}
 

void test(String[] args) throws Throwable {
    for (int how=0; how<4; how++) {
        final CountDownLatch done = new CountDownLatch(1);
        final AtomicInteger count = new AtomicInteger(0);
        final Timer timer = new Timer();
        final TimerTask task = new TimerTask() {
            @Override
            public void run() {
                checkScheduledExecutionTime(this);
                count.incrementAndGet();
                done.countDown();
            }};

        scheduleNow(timer, task, how);
        done.await();
        equal(count.get(), 1);
        checkScheduledExecutionTime(task);
        if (new java.util.Random().nextBoolean())
            sleep(10);
        check(task.cancel());
        timer.cancel();
        checkScheduledExecutionTime(task);
    }
}
 

public void createPeerConnectionFactory(final Context context,
    final PeerConnectionParameters peerConnectionParameters, final PeerConnectionEvents events) {
  this.peerConnectionParameters = peerConnectionParameters;
  this.events = events;
  // Reset variables to initial states.
  this.context = null;
  factory = null;
  videoCapturerStopped = false;
  isError = false;
  mediaStream = null;
  videoCapturer = null;
  renderVideo = true;
  localVideoTrack = null;
  remoteVideoTrack = null;
  localVideoSender = null;
  enableAudio = true;
  localAudioTrack = null;
  statsTimer = new Timer();

  executor.execute(new Runnable() {
    @Override
    public void run() {
      createPeerConnectionFactoryInternal(context);
    }
  });
}
 

private void sendContinuous(final String deviceId, final String datastream, final float minValue, final float maxValue, int period) {
    TimerTask task = new TimerTask() {
        @Override
        public void run() {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    sendOnce(deviceId, datastream, minValue, maxValue);
                }
            });
        }
    };
    mSendDataTimer = new Timer(true);
    mSendDataTimer.schedule(task, 0, period * 1000);
    mSendContinuousButton.setText(R.string.stop_sending);
    mDeviceIdLayout.setEnabled(false);
    mDataStreamLayout.setEnabled(false);
    mMinValueLayout.setEnabled(false);
    mMaxValueLayout.setEnabled(false);
    mPeriodLayout.setEnabled(false);
    mSendOneceButton.setEnabled(false);
    mSending = true;
}
 

@Override
public void start() {
    int bucketSize = checkBucketNum(properties.getBucketSize());
    if (isRuning.compareAndSet(false, true)) {
        for (int i = 1; i <= bucketSize; i++) {
            String     bName = NamedUtil.buildBucketName(properties.getPrefix(), properties.getName(), i);
            BucketTask task  = new BucketTask(bName);
            task.setJobOperationService(jobOperationService);
            task.setPoolName(NamedUtil.buildPoolName(properties.getPrefix(), properties.getName(), properties
                    .getOriginPool()));
            task.setReadyName(NamedUtil.buildPoolName(properties.getPrefix(), properties.getName(), properties
                    .getReadyName()));
            task.setProperties(properties);
            task.setLock(lock);
            String threadName = String.format(THREAD_NAME, i);
            Timer  timer      = new Timer(threadName, daemon);
            timer.schedule(task, 500, properties.getBuckRoundRobinTime());
            HOLD_TIMES.put(threadName, timer);
            LOGGER.info(String.format("Starting Bucket Thead %s ....", threadName));
        }

    }
}
 

public void createPeerConnectionFactory(final Context context,
    final PeerConnectionParameters peerConnectionParameters, final PeerConnectionEvents events) {
  this.peerConnectionParameters = peerConnectionParameters;
  this.events = events;
  videoCallEnabled = peerConnectionParameters.videoCallEnabled;
  dataChannelEnabled = peerConnectionParameters.dataChannelParameters != null;
  // Reset variables to initial states.
  factory = null;
  peerConnection = null;
  preferIsac = false;
  videoCapturerStopped = false;
  isError = false;
  queuedRemoteCandidates = null;
  localSdp = null; // either offer or answer SDP
  mediaStream = null;
  videoCapturer = null;
  renderVideo = true;
  localVideoTrack = null;
  remoteVideoTrack = null;
  localVideoSender = null;
  enableAudio = true;
  localAudioTrack = null;
  statsTimer = new Timer();

  executor.execute(new Runnable() {
    @Override
    public void run() {
      createPeerConnectionFactoryInternal(context);
    }
  });
}
 

@Override
public void actionPerformed(ActionEvent evt) {
    plotterCache.remove(key);
    Timer t = timerCache.remove(key);
    t.cancel();
    ((XMBeanAttributes) table).collapse(attributeName, this);
}
 

public void configure(final DesktopSearchMain aApplication, final Backend aBackend, final String aSearchURL, final Window aWindow) {
    gateway = new DesktopGateway(aApplication, DesktopSearchController.this);
    window = aWindow;
    application = aApplication;
    backend = aBackend;
    backend.setProgressListener(new FXProgressListener());
    watcherThread = new ProgressWatcherThread();
    webView.getEngine().setJavaScriptEnabled(true);
    webView.getEngine().getLoadWorker().stateProperty().addListener((ov, t, t1) -> {
        if (t1 == State.SUCCEEDED) {
            final var windowGlobalJSNamespace = (JSObject) webView.getEngine().executeScript("window");
            windowGlobalJSNamespace.setMember("desktop", gateway);
        }
    });
    webView.setContextMenuEnabled(false);
    webView.getEngine().load(aSearchURL);
    webView.getEngine().setJavaScriptEnabled(true);

    if (aApplication.getConfigurationManager().getConfiguration().isCrawlOnStartup()) {
        // Scedule a crawl run 5 seconds after startup...
        final var theTimer = new Timer();
        theTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                Platform.runLater(() -> recrawl());
            }
        }, 5000);
    }
}
 

@Override
public boolean onTouch(View v, MotionEvent event) {
    if (v.isClickable()) {
        /* handle press states */
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            v.setPressed(true);
            timer = new Timer();
            // Initial delay = length of a long press
            timer.schedule(new IncrementTask(0, ViewConfiguration.getLongPressTimeout()), ViewConfiguration.getLongPressTimeout());
        } else if (event.getAction() == MotionEvent.ACTION_UP) {
            timer.cancel();
            v.setPressed(false);
        }

        long lengthOfPress = event.getEventTime() - event.getDownTime();
        // If the button has been "tapped" then handle normally
        if (lengthOfPress < ViewConfiguration.getLongPressTimeout()
            && event.getAction() == MotionEvent.ACTION_UP) {
                incrementListener.increment();
        }

        return true;
    } else {
        /* If the view isn't clickable, let the touch be handled by others. */
        return false;
    }
}
 

private void animateProgress(final HomeItem item, final Timer timer, RootInfo root){
    try {
        final double percent = (((root.totalBytes - root.availableBytes) / (double) root.totalBytes) * 100);
        item.setProgress(0);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                if(Utils.isActivityAlive(getActivity())){
                    getActivity().runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if (item.getProgress() >= (int) percent) {
                                timer.cancel();
                            } else {
                                item.setProgress(item.getProgress() + 1);
                            }
                        }
                    });
                }
            }
        }, 50, 20);
    }
    catch (Exception e){
        item.setVisibility(View.GONE);
        Crashlytics.logException(e);
    }
}
 

private void startReading() {
    if (starting) {
        return;
    }
    starting = true;
    if (reader == null || !reader.isReading()) {

        if (reader == null) {
            reader = new LogReader();
            for (LogTableManager manager : tabManagers) {
                reader.addLogListener(manager);
            }

            reader.addPropertyChangeListener(WeakListeners.propertyChange(myPropertyChangeListener, reader));

            cmbLogDevicesSupport = new LogDevicesComboBoxSupport(reader);
            cmbLogDevicesSupport.attach(cmbLogDevices);
        }

        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                reader.startReading();
                starting = false;
            }
        }, 1000);
    } else {
        starting = false;
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
	// TODO Auto-generated method stub
	super.onCreate(savedInstanceState);
	requestWindowFeature(Window.FEATURE_NO_TITLE); 
	this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
	setContentView(R.layout.activity_splash);
	
	Timer timer = new Timer();
	timer.schedule(new TimerTask() {
		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			
			Intent intent = new Intent(SplashActivity.this, MainActivity.class);
			startActivity(intent);
			finish();
			
		}
	}, MainActivity.SPLASH_DURATION);

	tvZonCon = (TextView)findViewById(R.id.tv_zoncon);
	tvZonCon.setShadowLayer(2, 1, 1, getResources().getColor(R.color.black));
	tvZonCon.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20);
	tvZonCon.setVisibility(RelativeLayout.GONE);
	
}
 

@Override
public void onRegistered()
{
    if(mGoogleApiClient != null) {
        mGoogleApiClient.connect();
    } else {
        searchLocationWithoutGoogleService();
    }

    this.timer = new Timer();
    this.timer.scheduleAtFixedRate(new TimerTask()
    {
        @Override
        public void run()
        {
            Log.d("GPSCollector", "New Data Available?");

            Location location = null;
            if(mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
                if(!(Build.VERSION.SDK_INT >= 23 &&
                        !(ContextCompat.checkSelfPermission(context, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
                        ContextCompat.checkSelfPermission(context, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED))) {

                    location = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
                }
            }

            if(location == null || (lastKnownLocation != null && location.getTime() <= lastKnownLocation.getTime())) {
                location = getBestLocation();
            }

            if(location != null && (lastKnownLocation == null || location.getTime() > lastKnownLocation.getTime())) {
                lastKnownLocation = location;
                doLocationUpdate(lastKnownLocation);
            }
        }
    }, 0, getSensorRate());
}
 

public void pressed() {
	runTask.run();
	
	timer = new Timer();
	TimerTask runAction = new Task();

	timer.scheduleAtFixedRate(runAction, INITIAL_DELAY, STEP_DELAY);
}