timer.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   Timer.java

package org.gudy.azureus2.core3.util;

import java.io.PrintStream;
import java.lang.ref.WeakReference;
import java.util.*;

// Referenced classes of package org.gudy.azureus2.core3.util:
//			AERunnable, AEDiagnostics, AEMonitor, Debug, 
//			SystemTime, ThreadPool, TimerEvent, TimerEventPeriodic, 
//			TimerEventPerformer, AEDiagnosticsEvidenceGenerator, IndentWriter

public class Timer extends AERunnable
	implements SystemTime.ChangeListener
{
	private class evidenceGenerator
		implements AEDiagnosticsEvidenceGenerator
	{

		final Timer this$0;

		public void generate(IndentWriter writer)
		{
			ArrayList lines;
			int count;
			if (!Timer.DEBUG_TIMERS)
				return;
			lines = new ArrayList();
			count = 0;
			Timer.timers_mon.enter();
			for (Iterator iter = Timer.timers.iterator(); iter.hasNext();)
			{
				WeakReference timerRef = (WeakReference)iter.next();
				Timer timer = (Timer)timerRef.get();
				if (timer == null)
				{
					iter.remove();
				} else
				{
					count++;
					List events = timer.getEvents();
					lines.add((new StringBuilder()).append(timer.thread_pool.getName()).append(", ").append(events.size()).append(" events:").toString());
					Iterator it = events.iterator();
					while (it.hasNext()) 
					{
						TimerEvent ev = (TimerEvent)it.next();
						lines.add((new StringBuilder()).append("  ").append(ev.getString()).toString());
					}
				}
			}

			Timer.timers_mon.exit();
			break MISSING_BLOCK_LABEL_219;
			Exception exception;
			exception;
			Timer.timers_mon.exit();
			throw exception;
			writer.println((new StringBuilder()).append("Timers: ").append(count).toString());
			writer.indent();
			String line;
			for (Iterator iter = lines.iterator(); iter.hasNext(); writer.println(line))
				line = (String)iter.next();

			writer.exdent();
			break MISSING_BLOCK_LABEL_301;
			Throwable e;
			e;
			writer.println(e.toString());
		}

		private evidenceGenerator()
		{
			this$0 = Timer.this;
			super();
		}

	}


	private static boolean DEBUG_TIMERS = true;
	private static ArrayList timers = null;
	private static AEMonitor timers_mon = new AEMonitor("timers list");
	private ThreadPool thread_pool;
	private Set events;
	private long unique_id_next;
	private volatile boolean destroyed;
	private boolean indestructable;
	private boolean log;
	private int max_events_logged;

	public Timer(String name)
	{
		this(name, 1);
	}

	public Timer(String name, int thread_pool_size)
	{
		this(name, thread_pool_size, 5);
	}

	public Timer(String name, int thread_pool_size, int thread_priority)
	{
		events = new TreeSet();
		unique_id_next = 0L;
		if (!DEBUG_TIMERS)
			break MISSING_BLOCK_LABEL_95;
		timers_mon.enter();
		if (timers == null)
		{
			timers = new ArrayList();
			AEDiagnostics.addEvidenceGenerator(new evidenceGenerator());
		}
		timers.add(new WeakReference(this));
		timers_mon.exit();
		break MISSING_BLOCK_LABEL_95;
		Exception exception;
		exception;
		timers_mon.exit();
		throw exception;
		thread_pool = new ThreadPool(name, thread_pool_size);
		SystemTime.registerClockChangeListener(this);
		Thread t = new Thread(this, (new StringBuilder()).append("Timer:").append(name).toString());
		t.setDaemon(true);
		t.setPriority(thread_priority);
		t.start();
		return;
	}

	public void setIndestructable()
	{
		indestructable = true;
	}

	public synchronized List getEvents()
	{
		return new ArrayList(events);
	}

	public void setLogging(boolean _log)
	{
		log = _log;
	}

	public boolean getLogging()
	{
		return log;
	}

	public void setWarnWhenFull()
	{
		thread_pool.setWarnWhenFull();
	}

	public void setLogCPU()
	{
		thread_pool.setLogCPU();
	}

	public void runSupport()
	{
_L3:
		TimerEvent event_to_run;
		long now;
		TimerEvent next_event;
		Iterator it;
		long delay;
		TimerEvent event;
		try
		{
label0:
			{
				event_to_run = null;
				synchronized (this)
				{
					if (!destroyed)
						break label0;
				}
				break; /* Loop/switch isn't completed */
			}
		}
		catch (Throwable e)
		{
			Debug.printStackTrace(e);
		}
		continue; /* Loop/switch isn't completed */
		if (events.isEmpty())
		{
			wait();
		} else
		{
			now = SystemTime.getCurrentTime();
			next_event = (TimerEvent)events.iterator().next();
			delay = next_event.getWhen() - now;
			if (delay > 0L)
				wait(delay);
		}
		if (!destroyed)
			break MISSING_BLOCK_LABEL_94;
		timer;
		JVM INSTR monitorexit ;
		break; /* Loop/switch isn't completed */
		now = SystemTime.getCurrentTime();
		it = events.iterator();
		do
		{
			if (!it.hasNext())
				break;
			event = (TimerEvent)it.next();
			if (event.getWhen() > now)
				continue;
			event_to_run = event;
			it.remove();
			break;
		} while (true);
		timer;
		JVM INSTR monitorexit ;
		  goto _L1
		exception;
		throw exception;
_L1:
		if (event_to_run != null)
		{
			event_to_run.setHasRun();
			if (log)
				System.out.println((new StringBuilder()).append("running: ").append(event_to_run.getString()).toString());
			thread_pool.run(event_to_run.getRunnable());
		}
		continue; /* Loop/switch isn't completed */
		if (true) goto _L3; else goto _L2
_L2:
	}

	public void clockChanged(long current_time, long offset)
	{
		if (Math.abs(offset) >= 60000L)
			synchronized (this)
			{
				boolean resort = false;
				Iterator it = events.iterator();
				do
				{
					if (!it.hasNext())
						break;
					TimerEvent event = (TimerEvent)it.next();
					if (event.isAbsolute())
					{
						resort = true;
					} else
					{
						long old_when = event.getWhen();
						long new_when = old_when + offset;
						TimerEventPerformer performer = event.getPerformer();
						if (performer instanceof TimerEventPeriodic)
						{
							TimerEventPeriodic periodic_event = (TimerEventPeriodic)performer;
							long freq = periodic_event.getFrequency();
							if (new_when > current_time + freq + 5000L)
							{
								long adjusted_when = current_time + freq;
								Debug.outNoStack((new StringBuilder()).append(periodic_event.getName()).append(": clock change sanity check. Reduced schedule time from ").append(new_when).append(" to ").append(adjusted_when).toString());
								new_when = adjusted_when;
							}
						}
						if (old_when <= 0L || new_when >= 0L || offset <= 0L)
							event.setWhen(new_when);
					}
				} while (true);
				if (resort)
					events = new TreeSet(events);
				notify();
			}
	}

	public void adjustAllBy(long offset)
	{
		synchronized (this)
		{
			Iterator it = events.iterator();
			do
			{
				if (!it.hasNext())
					break;
				TimerEvent event = (TimerEvent)it.next();
				long old_when = event.getWhen();
				long new_when = old_when + offset;
				if (old_when <= 0L || new_when >= 0L || offset <= 0L)
					event.setWhen(new_when);
			} while (true);
			notify();
		}
	}

	public synchronized TimerEvent addEvent(long when, TimerEventPerformer performer)
	{
		return addEvent(SystemTime.getCurrentTime(), when, performer);
	}

	public synchronized TimerEvent addEvent(String name, long when, TimerEventPerformer performer)
	{
		return addEvent(name, SystemTime.getCurrentTime(), when, performer);
	}

	public synchronized TimerEvent addEvent(String name, long when, boolean absolute, TimerEventPerformer performer)
	{
		return addEvent(name, SystemTime.getCurrentTime(), when, absolute, performer);
	}

	public synchronized TimerEvent addEvent(long creation_time, long when, TimerEventPerformer performer)
	{
		return addEvent(((String) (null)), creation_time, when, performer);
	}

	public synchronized TimerEvent addEvent(long creation_time, long when, boolean absolute, TimerEventPerformer performer)
	{
		return addEvent(null, creation_time, when, absolute, performer);
	}

	public synchronized TimerEvent addEvent(String name, long creation_time, long when, TimerEventPerformer performer)
	{
		return addEvent(name, creation_time, when, false, performer);
	}

	public synchronized TimerEvent addEvent(String name, long creation_time, long when, boolean absolute, TimerEventPerformer performer)
	{
		TimerEvent event = new TimerEvent(this, unique_id_next++, creation_time, when, absolute, performer);
		if (name != null)
			event.setName(name);
		events.add(event);
		if (log && events.size() > max_events_logged)
		{
			max_events_logged = events.size();
			System.out.println((new StringBuilder()).append("Timer '").append(thread_pool.getName()).append("' - events = ").append(max_events_logged).toString());
		}
		notify();
		return event;
	}

	public synchronized TimerEventPeriodic addPeriodicEvent(long frequency, TimerEventPerformer performer)
	{
		return addPeriodicEvent(null, frequency, performer);
	}

	public synchronized TimerEventPeriodic addPeriodicEvent(String name, long frequency, TimerEventPerformer performer)
	{
		return addPeriodicEvent(name, frequency, false, performer);
	}

	public synchronized TimerEventPeriodic addPeriodicEvent(String name, long frequency, boolean absolute, TimerEventPerformer performer)
	{
		TimerEventPeriodic periodic_performer = new TimerEventPeriodic(this, frequency, absolute, performer);
		if (name != null)
			periodic_performer.setName(name);
		if (log)
			System.out.println((new StringBuilder()).append("Timer '").append(thread_pool.getName()).append("' - added ").append(periodic_performer.getString()).toString());
		return periodic_performer;
	}

	protected synchronized void cancelEvent(TimerEvent event)
	{
		if (events.contains(event))
		{
			events.remove(event);
			notify();
		}
	}

	public synchronized void destroy()
	{
		if (indestructable)
		{
			Debug.out((new StringBuilder()).append("Attempt to destroy indestructable timer '").append(getName()).append("'").toString());
		} else
		{
			destroyed = true;
			notify();
			SystemTime.unregisterClockChangeListener(this);
		}
		if (!DEBUG_TIMERS)
			break MISSING_BLOCK_LABEL_134;
		timers_mon.enter();
		Iterator iter = timers.iterator();
		do
		{
			if (!iter.hasNext())
				break;
			WeakReference timerRef = (WeakReference)iter.next();
			Object timer = timerRef.get();
			if (timer == null || timer == this)
				iter.remove();
		} while (true);
		timers_mon.exit();
		break MISSING_BLOCK_LABEL_134;
		Exception exception;
		exception;
		timers_mon.exit();
		throw exception;
	}

	public String getName()
	{
		return thread_pool.getName();
	}

	public synchronized void dump()
	{
		System.out.println((new StringBuilder()).append("Timer '").append(thread_pool.getName()).append("': dump").toString());
		TimerEvent ev;
		for (Iterator it = events.iterator(); it.hasNext(); System.out.println((new StringBuilder()).append("\t").append(ev.getString()).toString()))
			ev = (TimerEvent)it.next();

	}





}