【java】线程thread

线程状态

线程的状态通常包括新建、就绪、运行、阻塞、等待和终止。

1. 新建（New）：当创建一个新的线程对象时，线程处于新建状态。此时，尚未调用线程的start()方法。

2. 就绪（Runnable）：一旦调用了线程对象的start()方法，线程进入就绪状态。在就绪状态中，线程等待操作系统的调度以获取CPU时间片并开始执行。

3. 运行（Running）：当线程获得CPU时间片后，它开始执行其任务代码，此时线程处于运行状态。

4. 阻塞（Blocked）：线程在等待锁的释放或某些资源时会进入阻塞状态。例如，当一个线程尝试获取一个被其他线程持有的锁时，它会进入阻塞状态，直到该锁被释放。

5. 等待（Waiting）：线程执行wait()方法后会进入等待状态，此时它不占用任何资源，直到其他线程调用notify()或notifyAll()方法将其唤醒。

6. 超时等待（Timed Waiting）：与等待状态类似，但在此状态下的线程可以在指定的时间后自动返回到就绪状态，不需要其他线程的通知。

7. 终止（Terminated）：线程完成其run()方法的执行或因异常而退出时，将进入终止状态。终止的线程不再可运行。

线程池

参数

1. corePoolSize核心池大小：存放核心线程，不会被消灭
2. maximumPoolSize最大池大小
3. keepAliveTime最大生存时间
4. TimeUnit生存时间的单位
5. ArrayBlockingQueue（workQueue）任务对列
6. Executors线程产生工厂
7. ThreadPoolExecutor拒绝策略

线程池状态

RUNNING

表示线程池正常运行，既能接受新任务，也会正常处理队列中的任务

SHUTDOWN

当调用线程池的shutdown(）方法时，线程池就进入SHUTDOWN状态，表示线程池处于正在关闭状态，此状态下线程池不会接受新任务，但是会继续把队列中的任务处理完

STOP

当调用线程池的shutdownnow(）方法时，线程池就进入STOP状态，表示线程池处于正在停止状态，此状态下线程池既不会接受新任务了，也不会处理队列中的任务，并且正在运行的线程也会被中断

TIDYING

线程池中没有线程在运行后，线程池的状态就会自动变为TIDYING，并且会调用terminated()，该方法是空方法，留给程序员进行扩展。

TERMINATED

terminated(）方法执行完之后，线程池状态就会变为TERMINATED

线程池的底层工作原理

线程池内部是通过队列＋线程实现的，当我们利用线程池执行任务时：

1．如果此时线程池中的线程数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

2．如果此时线程池中的线程数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列。

3．如果此时线程池中的线程数量大于等于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

4．如果此时线程池中的线程数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

5．当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数

创建线程执行任务

方法一：继承Thread类

public class test extends Thread {
    public static void main(String[] args) {
        test t = new test();
        t.start();
    }
    @Override
    public void run() {
        System.out.println("hello");
    }
}

方法二：实现Runna接口

public class test implements Runnable{
    public static void main(String[] args) {
        Thread t=new Thread(new test());
        t.start();
    }
    @Override
    public void run() {
        System.out.println("hello");
    }
}

方法三：实现Callable接口

public class test implements Callable<String> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new test());
        Thread thread = new Thread(futureTask);
        thread.start();
        String result = futureTask.get();
        System.out.println(result);
    }

    @Override
    public String call() throws Exception {
        return "null";
    }
}

方法四：利用线程池来创建线程

public class test implements Runnable {
    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        executorService.execute(new test());
    }


    @Override
    public void run() {
        System.out.println("test");
    }
}

为什么不用Executors

发现创建的队列为LinkedBlockingQueue，是一个无界阻塞队列，如果使用该线程池执行任务，如果任务过多就会不断的添加到队列中，任务越多占用的内存就越多，最终可能耗尽内存，导致OOM。

Executors来创建线程池也不能自定义线程的名字，不利于排查问题，所以建议直接使用ThreadPoolExecutor来定义线程池，这样可以灵活控制。

线程安全

如果一个对象可以安全地被多个线程同时使用，那它就是线程安全的。

本质

可见性问题

ThreadLocal

ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意方法中获取缓存的数据

实现原理

ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值

应用场景

连接管理：一个线程持有一个连接（例如数据库连接），该连接对象可以在不同的方法之间进行传递，线程之间不共享同一个连接

内存泄漏

因为当ThreadLocal对象使用完之后，应该要把设置的key,value，也就是Entry对象进行回收，但线程池中的线程不会回收，而线程对象是通过强引用指向ThreadLocalMap,ThreadLocalMap也是通过强引用指向Entry对象，线程不被回收，Entry对象也就不会被回收，从而出现内存泄漏

解决办法：在使用了ThreadLocal对象之后，手动调用ThreadLocal的remove方法，手动清楚Entry对象