private void init(ThreadGroup g, Runnable target, String name,                      long stackSize) {        init(g, target, name, stackSize, null);    }    private void init(ThreadGroup g, Runnable target, String name,                      long stackSize, AccessControlContext acc) {        if (name == null) {            throw new NullPointerException("name cannot be null");        }        this.name = name.toCharArray();        Thread parent = currentThread();        SecurityManager security = System.getSecurityManager();        if (g == null) {            /* Determine if it's an applet or not */            /* If there is a security manager, ask the security manager               what to do. */            if (security != null) {                g = security.getThreadGroup();            }            /* If the security doesn't have a strong opinion of the matter               use the parent thread group. */            if (g == null) {                g = parent.getThreadGroup();            }        }        /* checkAccess regardless of whether or not threadgroup is           explicitly passed in. */        g.checkAccess();        /*         * Do we have the required permissions?         */        if (security != null) {            if (isCCLOverridden(getClass())) {                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);            }        }        g.addUnstarted();        this.group = g;        this.daemon = parent.isDaemon();        this.priority = parent.getPriority();        if (security == null || isCCLOverridden(parent.getClass()))            this.contextClassLoader = parent.getContextClassLoader();        else            this.contextClassLoader = parent.contextClassLoader;        this.inheritedAccessControlContext =                acc != null ? acc : AccessController.getContext();        this.target = target;        setPriority(priority);        if (parent.inheritableThreadLocals != null)            this.inheritableThreadLocals =                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);        /* Stash the specified stack size in case the VM cares */        this.stackSize = stackSize;        /* Set thread ID */        tid = nextThreadID();    }    public Thread() {        init(null, null, "Thread-" + nextThreadNum(), 0);    }      public Thread(Runnable target) {        init(null, target, "Thread-" + nextThreadNum(), 0);    }    Thread(Runnable target, AccessControlContext acc) {        init(null, target, "Thread-" + nextThreadNum(), 0, acc);    }   // 线程名    public Thread(String name) {        init(null, null, name, 0);    }    //线程组和线程名    public Thread(ThreadGroup group, String name) {        init(group, null, name, 0);    }    //线程任务，线程名    public Thread(Runnable target, String name){        init(null, target, name, 0);    }    // 线程组， 线程任务， 线程名 ，栈大小    public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {        init(group, target, name, stackSize);    }

// 类加载的时候，调用本地的注册本地方静态方法， 这个方法是本地方法    private static native void registerNatives();    static {        registerNatives();    }    private volatile char  name[];    private int            priority;    private Thread         threadQ;    private long           eetop;    /* Whether or not to single_step this thread. */    private boolean     single_step;    /* Whether or not the thread is a daemon thread. */    // 设设置这个线程是否是守护线程    private boolean     daemon = false;    /* JVM state */    private boolean     stillborn = false;    /* What will be run. */    // 要执行的run方法的对象    private Runnable target;    /* The group of this thread */    // 这个线程的线程组    private ThreadGroup group;    /* The context ClassLoader for this thread */    // 这个线程的上下文类加载器    private ClassLoader contextClassLoader;    /* The inherited AccessControlContext of this thread */    private AccessControlContext inheritedAccessControlContext;    /* For autonumbering anonymous threads. */    private static int threadInitNumber;    private static synchronized int nextThreadNum() {        return threadInitNumber++;    }    /* ThreadLocal values pertaining to this thread. This map is maintained     * by the ThreadLocal class. */    ThreadLocal.ThreadLocalMap threadLocals = null;    /*     * InheritableThreadLocal values pertaining to this thread. This map is     * maintained by the InheritableThreadLocal class.     */    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;    /*     * The requested stack size for this thread, or 0 if the creator did     * not specify a stack size.  It is up to the VM to do whatever it     * likes with this number; some VMs will ignore it.     */     // 给这个线程设置的栈的大小,默认为0     private long stackSize;    /*     * JVM-private state that persists after native thread termination.     */    private long nativeParkEventPointer;    /*     * Thread ID     */       //线程id    private long tid;    /* For generating thread ID */    private static long threadSeqNumber;    /* Java thread status for tools,     * initialized to indicate thread 'not yet started'     */    private volatile int threadStatus = 0;    private static synchronized long nextThreadID() {        return ++threadSeqNumber;    }    /**     * The argument supplied to the current call to     * java.util.concurrent.locks.LockSupport.park.     * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker     * Accessed using java.util.concurrent.locks.LockSupport.getBlocker     */    volatile Object parkBlocker;    /* The object in which this thread is blocked in an interruptible I/O     * operation, if any.  The blocker's interrupt method should be invoked     * after setting this thread's interrupt status.     */    private volatile Interruptible blocker;    private final Object blockerLock = new Object();    /* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code     */    void blockedOn(Interruptible b) {        synchronized (blockerLock) {            blocker = b;        }    }    /**     * The minimum priority that a thread can have.     */     // 线程执行的最低优先级 为1    public final static int MIN_PRIORITY = 1;   /**     * The default priority that is assigned to a thread.     */     // 线程默认的执行优先级为 5    public final static int NORM_PRIORITY = 5;    /**     * The maximum priority that a thread can have.     */     // 线程执行的最高的优先级为 10    public final static int MAX_PRIORITY = 10;

public class MyCallable implements Callable<String> {      @Override      public String call() throws Exception {            String value="test";          System.out.println("start");          Thread.sleep(5000);          System.out.println("end");          return value;        }  }  public class FutureTaskDemo {        public static void main(String[] main) throws ExecutionException, InterruptedException {          FutureTask<String> futureTask=new FutureTask<String>(new MyCallable());            new Thread(futureTask).start();            if (!futureTask.isDone()){              System.out.println("waiting");          }          System.out.println("return"+futureTask.get());      }  }

public class ThreadPoolDemo {      public static void main(String[] args){          ExecutorService executorService= Executors.newCachedThreadPool();          Future<String> futureTask=executorService.submit(new MyCallable());          if (!futureTask.isDone()){              System.out.println("wait");          }          try {              System.out.println(futureTask.get());          }catch (InterruptedException ex){              ex.printStackTrace();          }catch (ExecutionException ex){              ex.printStackTrace();          }finally {              executorService.shutdown();          }        }  }