多线程（1）- 认识线程

---

前言

主要包括线程概念，线程状态

---

扩展：

概念

1. 进程： 计算机的一个任务就是一个进程。
2. 线程：进程的最下执行单元，每个进程至少要有一个线程是在运行中。
   程序计数器：指向正在执行的指令指针
   局部变量表：维护传递过来的变量信息
   线程各自的生命周期
   当启动了一个Java虚拟机（JVM）时，从操作系统就会创建一个新的进程（JVM进程），JVM进程会创建并派生很多线程

1、认识线程的5种状态

• NEW：创建一个线程
• RUNNABLE：调用start方法，此时才是真正的在JVM进程中创建了一个线程，无CPU的调度，处于可执行状态，只能意外终止或进入RUNNING状态
• RUNNING：线程抢到了CPU时间片，处于运行中状态
• BLOCKED：阻塞状态
• TERMINATED：线程死亡，生命周期结束
  
  
  

2、线程的创建

2.1 Thread类

//方式一
new Thread(){
	//匿名内部类创建一个线程
	@Override
	public void run(){
		dosomething();
	}
}.start();

//方式二
new Thread(TryConcurrency::dosomething).start();

2.2 实现Runnable

/**
     * 当前线程使用Thread.currentThread()获取
     */
    static class RunnableCreate implements Runnable {

        @Override
        public void run() {
            System.out.println(this.getClass().getSimpleName() + "do something");
        }
    }

	public static void testRunnableCreate() {
        RunnableCreate runnableCreate = new RunnableCreate();
        new Thread(runnableCreate).start();
    }

2.3 使用Callable

/**
     * 当前线程使用Thread.currentThread()获取
     * 有返回值 可以抛出异常
     */
    static class CallableCreate implements Callable {

        @Override
        public Object call() throws Exception {
            System.out.println(this.getClass().getSimpleName() + "do something");
            throw new RuntimeException();
        }
    }

public static void testCallableCreate() {
        //CallableCreate callableCreate = new CallableCreate();
        FutureTask<Integer> task = new FutureTask((Callable<Integer>) () -> {
            Integer count = 0;
            for (int i = 0; i < 1000; i++) {
                count += i;
            }
            return count;
        });
        new Thread(task).start();
        Object obj = null;
        try {
            obj = task.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(obj);
    }

一个线程进行多次调用start方法

/**
     * 当前线程使用this获取
     */
    static class ThreadCreate extends Thread {
        @Override
        public void run() {
            System.out.println(this.getClass().getSimpleName() + "do something");
        }
    }
    
ThreadCreate threadCreate = new ThreadCreate();
        threadCreate.start();
        threadCreate.start();

//执行结果
ThreadCreatedo something
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:708)
	at com.today.roc.go.understand.thread.ThreadCreateMain.testThreadCreate(ThreadCreateMain.java:85)
	at com.today.roc.go.understand.thread.ThreadCreateMain.main(ThreadCreateMain.java:77)

一个线程调用start执行完之后，再次调用start方法，此时threadState=2 ，抛错

ThreadCreate threadCreate = new ThreadCreate();
        threadCreate.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadCreate.start();  
执行结果：
ThreadCreatedo something
ThreadCreatedo something
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:708)
	at com.today.roc.go.understand.thread.ThreadCreateMain.testThreadCreate(ThreadCreateMain.java:90)
	at com.today.roc.go.understand.thread.ThreadCreateMain.main(ThreadCreateMain.java:77)
Disconnected from the target VM, address: '127.0.0.1:56676', transport: 'socket'
      

线程，父线程，线程组

• 1、一个线程的创建一定是另一个线程参与创建的
  2、被创建线程的创建者是父线程

main函数所在的线程是由JVM线程创建的，也就是main线程，意味着前面创建的线程父线程都是main线程

• 1、main线程线程组为main
  2、构造线程时如果没有显示指定线程组，那么ThreadGroup与父线程一致

在默认设置中父子线程所在的线程组是一样，且他们的优先级，daemon是一样的

有了Thread为什么还要Runnable？

• Thread负责线程本身的职责与控制，Runnable负责逻辑执行单元部分

Thread的构造方法

new Thread(ThreadGroup group Runnable runnable  String name long stackSize )

group：线程组，不设置默认是父线程的线程组 main线程组
runnable：执行单元
name：线程名称
stackSize：size越大则递归的程度就越深，越小则线程的数量就越多

守护线程

JVM中如果不存在非守护线程，那么JVM将会退出
守护线程有自动结束生命周期的的特性
设置线程为守护线程

setDaemon(true);

守护线程经常用作执行一些后台任务。