public class TestThread extends Thread {@Overridepublic void run() {//do your something}
}

private void runMyThread(){new TestThread().start();
}

public class Thread implements Runnable{
}

private void create(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {Thread currentThread = Thread.currentThread();if (group == null) {group = currentThread.getThreadGroup();}if (group.isDestroyed()) {throw new IllegalThreadStateException("Group already destroyed");}this.group = group;synchronized (Thread.class) {id = ++Thread.count;}if (threadName == null) {this.name = "Thread-" + id;} else {this.name = threadName;}this.target = runnable;this.stackSize = stackSize;this.priority = currentThread.getPriority();this.contextClassLoader = currentThread.contextClassLoader;// Transfer over InheritableThreadLocals.if (currentThread.inheritableValues != null) {inheritableValues = new ThreadLocal.Values(currentThread.inheritableValues);}// add ourselves to our ThreadGroup of choicethis.group.addThread(this);}

public void run() {if (target != null) {target.run();}}

public synchronized void start() {checkNotStarted();hasBeenStarted = true;nativeCreate(this, stackSize, daemon);}private native static void nativeCreate(Thread t, long stackSize, boolean daemon);

public static void sleep(long millis, int nanos) throws InterruptedException {if (millis < 0) {throw new IllegalArgumentException("millis < 0: " + millis);}if (nanos < 0) {throw new IllegalArgumentException("nanos < 0: " + nanos);}if (nanos > 999999) {throw new IllegalArgumentException("nanos > 999999: " + nanos);}// The JLS 3rd edition, section 17.9 says: "...sleep for zero// time...need not have observable effects."if (millis == 0 && nanos == 0) {// ...but we still have to handle being interrupted.if (Thread.interrupted()) {throw new InterruptedException();}return;}long start = System.nanoTime();long duration = (millis * NANOS_PER_MILLI) + nanos;Object lock = currentThread().lock;// Wait may return early, so loop until sleep duration passes.synchronized (lock) {while (true) {sleep(lock, millis, nanos);long now = System.nanoTime();long elapsed = now - start;if (elapsed >= duration) {break;}duration -= elapsed;start = now;millis = duration / NANOS_PER_MILLI;nanos = (int) (duration % NANOS_PER_MILLI);}}}

private static native void sleep(Object lock, long millis, int nanos);

public void interrupt() {// Interrupt this thread before running actions so that other// threads that observe the interrupt as a result of an action// will see that this thread is in the interrupted state.nativeInterrupt();synchronized (interruptActions) {for (int i = interruptActions.size() - 1; i >= 0; i--) {interruptActions.get(i).run();}}}private native void nativeInterrupt();

public interface Runnable {/*** Starts executing the active part of the class' code. This method is* called when a thread is started that has been created with a class which* implements {@code Runnable}.*/public void run();
}

public class TestAsyncTask extends AsyncTask<String,Object,String> {@Overrideprotected String doInBackground(String... params) {return null;}@Overrideprotected void onPostExecute(String s) {super.onPostExecute(s);}@Overrideprotected void onProgressUpdate(Object... values) {super.onProgressUpdate(values);}
}

public abstract class AsyncTask<Params, Progress, Result> {
}

private void testMyAsyncTask(){new TestAsyncTask().execute(url);
}

@MainThreadpublic final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {if (mStatus != Status.PENDING) {switch (mStatus) {case RUNNING:throw new IllegalStateException("Cannot execute task:"+ " the task is already running.");case FINISHED:throw new IllegalStateException("Cannot execute task:"+ " the task has already been executed "+ "(a task can be executed only once)");}}mStatus = Status.RUNNING;onPreExecute();mWorker.mParams = params;exec.execute(mFuture);return this;}