Java¸ß²¢·¢±à³Ì»ù´¡Ö®Thread¹¹Ô캯Êý´óÓÐÄÚº­

    public Thread() {
        this(null, null, "Thread-" + nextThreadNum(), 0);
    }

    public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }

    Thread(Runnable target, @SuppressWarnings("removal") AccessControlContext acc) {
        this(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
    }

    public Thread(ThreadGroup group, Runnable target) {
        this(group, target, "Thread-" + nextThreadNum(), 0);
    }

    public Thread(String name) {
        this(null, null, name, 0);
    }

    public Thread(ThreadGroup group, String name) {
        this(group, null, name, 0);
    }

    public Thread(Runnable target, String name) {
        this(null, target, name, 0);
    }

    public Thread(ThreadGroup group, Runnable target, String name) {
        this(group, target, name, 0);
    }

    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        this(group, target, name, stackSize, null, true);
    }

    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize, boolean inheritThreadLocals) {
        this(group, target, name, stackSize, null, inheritThreadLocals);
    }

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, null, gname)}, where {@code gname} is a newly generated
     * name. Automatically generated names are of the form
     * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
     */
    public Thread() {
        this(null, null, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, target, gname)}, where {@code gname} is a newly generated
     * name. Automatically generated names are of the form
     * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this classes {@code run} method does
     *         nothing.
     */
    public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (group, target, gname)} ,where {@code gname} is a newly generated
     * name. Automatically generated names are of the form
     * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
     *
     * @param  group
     *         the thread group. If {@code null} and there is a security
     *         manager, the group is determined by {@linkplain
     *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
     *         If there is not a security manager or {@code
     *         SecurityManager.getThreadGroup()} returns {@code null}, the group
     *         is set to the current thread's thread group.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this thread's run method is invoked.
     *
     * @throws  SecurityException
     *          if the current thread cannot create a thread in the specified
     *          thread group
     */
    public Thread(ThreadGroup group, Runnable target) {
        this(group, target, "Thread-" + nextThreadNum(), 0);
    }

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, null, name)}.
     *
     * @param   name
     *          the name of the new thread
     */
    public Thread(String name) {
        this(null, null, name, 0);
    }
/**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (group, null, name)}.
     *
     * @param  group
     *         the thread group. If {@code null} and there is a security
     *         manager, the group is determined by {@linkplain
     *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
     *         If there is not a security manager or {@code
     *         SecurityManager.getThreadGroup()} returns {@code null}, the group
     *         is set to the current thread's thread group.
     *
     * @param  name
     *         the name of the new thread
     *
     * @throws  SecurityException
     *          if the current thread cannot create a thread in the specified
     *          thread group
     */
    public Thread(ThreadGroup group, String name) {
        this(group, null, name, 0);
    }

    /**
     * Allocates a new {@code Thread} object. This constructor has the same
     * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
     * {@code (null, target, name)}.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this thread's run method is invoked.
     *
     * @param  name
     *         the name of the new thread
     */
    public Thread(Runnable target, String name) {
        this(null, target, name, 0);
    }

    /**
     *
     * @param  group
     *         the thread group. If {@code null} and there is a security
     *         manager, the group is determined by {@linkplain
     *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
     *         If there is not a security manager or {@code
     *         SecurityManager.getThreadGroup()} returns {@code null}, the group
     *         is set to the current thread's thread group.
     *
     * @param  target
     *         the object whose {@code run} method is invoked when this thread
     *         is started. If {@code null}, this thread's run method is invoked.
     *
     * @param  name
     *         the name of the new thread
     *
     * @throws  SecurityException
     *          if the current thread cannot create a thread in the specified
     *          thread group or cannot override the context class loader methods.
     */
    public Thread(ThreadGroup group, Runnable target, String name) {
        this(group, target, name, 0);
    }

    /**
     * Changes the name of this thread to be equal to the argument {@code name}.
     * <p>
     * First the {@code checkAccess} method of this thread is called
     * with no arguments. This may result in throwing a
     * {@code SecurityException}.
     *
     * @param      name   the new name for this thread.
     * @throws     SecurityException  if the current thread cannot modify this
     *             thread.
     * @see        #getName
     * @see        #checkAccess()
     */
    public final synchronized void setName(String name) {
        checkAccess();
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;
        if (threadStatus != 0) {
            setNativeName(name);
        }
    }

/**
     * Initializes a Thread.
     *
     * @param g the Thread group
     * @param target the object whose run() method gets called
     * @param name the name of the new Thread
     * @param stackSize the desired stack size for the new thread, or
     *        zero to indicate that this parameter is to be ignored.
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     * @param inheritThreadLocals if {@code true}, inherit initial values for
     *            inheritable thread-locals from the constructing thread
     */
    @SuppressWarnings("removal")
    private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        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 manager doesn't have a strong opinion
               on 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(
                        SecurityConstants.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 (inheritThreadLocals && 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 */
        this.tid = nextThreadID();
    }

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 manager doesn't have a strong opinion
        on 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(
                SecurityConstants.SUBCLASS_IMPLEMENTATION_PERMISSION);
    }
}

g.addUnstarted();

this.group = g;

package engineer.concurrent.battle.onebasic;

/**
 * ²âÊÔ Thread Óë ThreadGroup
 */
public class ThreadGroupTest {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1");
        ThreadGroup group = new ThreadGroup("group1");
        Thread t2 = new Thread(group,"t2");
        ThreadGroup mainThreadGroup = Thread.currentThread().getThreadGroup();
        System.out.println("Main thread belong group:"+ mainThreadGroup.getName());
        System.out.println("tl and main belong the same group:" + (mainThreadGroup== t1.getThreadGroup()));
        System.out.println("t2 thread group not belong main group:" + (mainThreadGroup== t2.getThreadGroup()));
        System.out.println("t2 thread group belong main TestGroup:" + (group == t2.getThreadGroup()));
    }
}

Main thread belong group:main
tl and main belong the same group:true
t2 thread group not belong main group:false
t2 thread group belong main TestGroup:true

The stack size is the approximate number of bytes of address space that the virtual machine is to allocate for this thread's stack. The effect of the stackSize parameter, if any, is highly platform dependent.

On some platforms, specifying a higher value for the stackSize parameter may allow a thread to achieve greater recursion depth before throwing a StackOverflowError. Similarly, specifying a lower value may allow a greater number of threads to exist concurrently without throwing an OutOfMemoryError (or other internal error). The details of the relationship between the value of the stackSize parameter and the maximum recursion depth and concurrency level are platform-dependent. On some platforms, the value of the stackSize parameter may have no effect whatsoever.

The virtual machine is free to treat the stackSize parameter as a suggestion. If the specified value is unreasonably low for the platform, the virtual machine may instead use some platform-specific minimum value; if the specified value is unreasonably high, the virtual machine may instead use some platform-specific maximum. Likewise, the virtual machine is free to round the specified value up or down as it sees fit (or to ignore it completely).

Specifying a value of zero for the stackSize parameter will cause this constructor to behave exactly like the Thread(ThreadGroup, Runnable, String) constructor.

Due to the platform-dependent nature of the behavior of this constructor, extreme care should be exercised in its use. The thread stack size necessary to perform a given computation will likely vary from one JRE implementation to another. In light of this variation, careful tuning of the stack size parameter may be required, and the tuning may need to be repeated for each JRE implementation on which an application is to run.

Implementation note: Java platform implementers are encouraged to document their implementation's behavior with respect to the stackSize parameter.

¶ÑÕ»´óСÊÇÐéÄâ»úΪ¸ÃÏ̵߳ĶÑÕ»·ÖÅäµÄ´óÖÂ×Ö½ÚÊý¡£stackSize²ÎÊýµÄЧ¹ûÔںܴó³Ì¶ÈÉÏÈ¡¾öÓÚƽ̨¡£

ÔÚijЩƽ̨ÉÏ£¬ÎªstackSize²ÎÊýÖ¸¶¨½Ï¸ßµÄÖµ¿ÉÄÜÔÊÐíÏß³ÌÔÚÒý·¢StackOverflowError֮ǰʵÏÖ¸ü´óµÄµÝ¹éÉî¶È¡£Í¬Ñù£¬Ö¸¶¨½ÏµÍµÄÖµ¿ÉÄÜÔÊÐí¸ü¶àµÄÏ̲߳¢·¢´æÔÚ£¬¶ø²»»áÒý·¢OutOfMemoryError£¨»òÆäËûÄÚ²¿´íÎ󣩡£stackSize²ÎÊýµÄÖµÓë×î´óµÝ¹éÉî¶ÈºÍ²¢·¢¼¶±ðÖ®¼äµÄ¹Øϵϸ½ÚÒòƽ̨¶øÒì¡£ÔÚijЩƽ̨ÉÏ£¬stackSize²ÎÊýµÄÖµ¿ÉÄܸù±¾²»Æð×÷Óá£

ÐéÄâ»ú¿ÉÒÔ½«stackSize²ÎÊýÊÓΪ½¨Òé¡£Èç¹ûÖ¸¶¨µÄÖµ¶ÔÓÚƽ̨À´Ëµ¹ýµÍ£¬ÐéÄâ»ú¿ÉÄÜ»áʹÓÃһЩÌض¨ÓÚƽ̨µÄ×îСֵ£»Èç¹ûÖ¸¶¨µÄÖµ¹ý¸ß£¬ÐéÄâ»ú¿ÉÄÜ»áʹÓÃһЩÌض¨ÓÚƽ̨µÄ×î´óÖµ¡£Í¬ÑùµØ£¬ÐéÄâ»ú¿ÉÒÔ×ÔÐоö¶¨ÊÇ·ñ½«Ö¸¶¨µÄÖµÏòÉÏÉáÈë»òÏòÏÂÉáÈ루»òÍêÈ«ºöÂÔËü£©¡£

¶ÔÓÚstackSize²ÎÊýÉèÖÃΪ0£¬¸Ã¹¹Ô캯ÊýµÄÐÐΪ½«ÓëThread(ThreadGroup, Runnable, String)¹¹Ô캯ÊýÍêÈ«Ïàͬ¡£

ÓÉÓڴ˹¹Ô캯ÊýµÄÐÐΪÒÀÀµÓÚƽ̨£¬Ê¹ÓÃʱӦ¼«¶È½÷É÷¡£Ö´Ðиø¶¨¼ÆËãËùÐèµÄÏ̶߳ÑÕ»´óС¿ÉÄÜÒòJREʵÏÖ¶øÒì¡£¼øÓÚÕâÖÖ²îÒ죬¿ÉÄÜÐèÒª¶ÔstackSize²ÎÊý½øÐÐ×Ðϸµ÷Õû£¬²¢ÇÒÔÚÓ¦ÓóÌÐòÒªÔËÐеÄÿ¸öJREʵÏÖÉÏ¿ÉÄÜÐèÒªÖظ´µ÷Õû¡£

ʵʩעÒâÊÂÏ¹ÄÀøJavaƽ̨ʵÏÖÕ߼ǼÆäʵÏÖÓëstackSize²ÎÊýÏà¹ØµÄÐÐΪ¡£

package engineer.concurrent.battle.onebasic;
import org.junit.jupiter.api.Test;

public class ThreadStackSizeTest {
    private final static int THREAD_COUNT = Integer.MAX_VALUE;
    @Test
    public void testStackSize1() {
        // 6914
        stackSizeRunMethod(10);
    }

    @Test
    public void testStackSize2() {
        // 4009
        stackSizeRunMethod(100);
    }

    @Test
    public void testStackSize3() {
        //6461
        stackSizeRunMethod(1000);
    }

    @Test
    public void testStackSize4() {
        //153
        stackSizeRunMethod(10000);
    }

    public static void stackSizeRunMethod(int stackSize) {
        ThreadGroup group = new ThreadGroup("stackSizeRunMethod");
        Runnable runnable = new Runnable() {
            public void run() {
                int i = 1;
                try {
                    recurse(i);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                } catch (Error e) {
                    System.out.println(e.getMessage());
                }
            }
            private void recurse(int i) {
                System.out.println(i);
                if (i < THREAD_COUNT) {
                    recurse(i + 1);
                }
            }
        };
        Thread thread = new Thread(group, runnable, "ThreadStackSizeTest", stackSize);
        thread.start();
    }
}

package engineer.concurrent.battle.onebasic;

public class DaemonThread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (true) {
                System.out.println("I am a daemon thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // ½«Ïß³ÌÉèÖÃΪÊØ»¤Ïß³Ì
        thread.setDaemon(true);
        thread.start();
        Thread.sleep(2000);
        System.out.println("I am main thread and end");
    }
}