1:新建状态(new):使用new创建一个线程对象,仅仅在堆中分配内存空间,在调用start方法之前.
新建状态下,线程压根就没有启动,仅仅只是存在一个线程对象而已.
Thread t = new Thread();//此时t就属于新建状态

当新建状态下的线程对象调用了start方法,此时从新建状态进入可运行状态.
线程对象的start方法只能调用一次,否则报错:IllegalThreadStateException.

2:可运行状态(runnable):分成两种状态，ready和running。分别表示就绪状态和运行状态。
就绪状态:线程对象调用start方法之后,等待JVM的调度(此时该线程并没有运行).
运行状态:线程对象获得JVM调度,如果存在多个CPU,那么允许多个线程并行运行.


3:阻塞状态(blocked):正在运行的线程因为某些原因放弃CPU,暂时停止运行,就会进入阻塞状态.
此时JVM不会给线程分配CPU,直到线程重新进入就绪状态,才有机会转到运行状态.
阻塞状态只能先进入就绪状态,不能直接进入运行状态.
阻塞状态的两种情况:
1):当A线程处于运行过程时,试图获取同步锁时,却被B线程获取.此时JVM把当前A线程存到对象的锁池中,A线程进入阻塞状态.
2):当线程处于运行过程时,发出了IO请求时,此时进入阻塞状态.

4:等待状态(waiting)(等待状态只能被其他线程唤醒):此时使用的无参数的wait方法,
1):当线程处于运行过程时,调用了wait()方法,此时JVM把当前线程存在对象等待池中.

5:计时等待状态(timed waiting)(使用了带参数的wait方法或者sleep方法)
1):当线程处于运行过程时,调用了wait(long time)方法,此时JVM把当前线程存在对象等待池中.
2):当前线程执行了sleep(long time)方法.

6:终止状态(terminated):通常称为死亡状态，表示线程终止.
1):正常执行完run方法而退出(正常死亡).
2):遇到异常而退出(出现异常之后,程序就会中断)(意外死亡).
线程一旦终止,就不能再重启启动,否则报错(IllegalThreadStateException).

线程组

线程组： 把多个线程组合到一起。

它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。

线程默认情况下属于main线程组

private static void method1() {
        //线程在默认线程数组中

        //创建对象
        MyRunnable mr = new MyRunnable();

        //创建线程对象
        Thread t1 = new Thread(mr,"阿三");
        Thread t2 = new Thread(mr,"阿四");

        //如果不把线程添加到自定义线程数组中，那么它们会默认添加到系统给的一个线程数组中
        //看看这个默认的线程数组是什么
        //public final ThreadGroup getThreadGroup()返回该线程所属的线程组。 如果该线程已经终止（停止运行），该方法则返回 null。
        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();

        //查看这个数组的名称
        System.out.println(tg1.getName());
        // 通过结果我们知道了：线程默认情况下属于main线程组

        //链式方法查看这个数组的名称
        // 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组
        System.out.println(Thread.currentThread().getThreadGroup().getName());

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
我们再让线程添加到自定义线程组中，并对线程组中的线程进行统一控制

  private static void method2() {
      //线程添加到自定义线程数组中

      //创建对象
      MyRunnable mr = new MyRunnable();
      //创建线程数组
      ThreadGroup tg = new ThreadGroup("自定义线程数组");

      //创建线程
      //Thread(ThreadGroup group, Runnable target, String name)
      //分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。
      Thread t1 = new Thread(tg,mr,"阿三");
      Thread t2 = new Thread(tg,mr,"阿四");

      //查看现在t1、t2所在的线程数组的名称
      System.out.println(t1.getThreadGroup().getName());

      //可以统一对t1、t2进行操作
      //把tg数组里的所有线程都设置成守护线程
      tg.setDaemon(true);

  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
获取当前项目所有线程

public Thread[] findAllThread(){
  ThreadGroup currentGroup =Thread.currentThread().getThreadGroup();

  while (currentGroup.getParent()!=null){
      // 返回此线程组的父线程组
      currentGroup=currentGroup.getParent();
  }
  //此线程组中活动线程的估计数
  int noThreads = currentGroup.activeCount();

  Thread[] lstThreads = new Thread[noThreads];
  //把对此线程组中的所有活动子组的引用复制到指定数组中。
  currentGroup.enumerate(lstThreads);

  for (Thread thread : lstThreads) {
      System.out.println("线程数量："+noThreads+" 线程id：" + thread.getId() + " 线程名称：" + thread.getName() + " 线程状态：" + thread.getState());
  }
  return lstThreads;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
常用方法摘要

int activeCount()：返回此线程组中活动线程的估计数。
void interrupt()：中断此线程组中的所有线程。
---------------------
【转载，仅作分享，侵删】
作者：imxlw00
原文：https://blog.csdn.net/imxlw00/article/details/85345866

奈斯