基础知识：浅谈java多线程

多线程的描述

随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是4 核、8 核甚至 16 核的也都不少见。而在实际的系统运行的过程中，如何能够尽可能地利用我们的服务器CPU呢？越来越多的程序在执行任务的时候开始使用多线程，主要是为了提高资源使用效率来提高系统的效率。采用多线程能同步完成多项任务，使用它的特点：可以把占据长时间的程序中的任务放到后台去处理。
我们的程序在运行的过程中是一个进程，在进程中可以细化为多个线程，每个线程都有自己独立的栈、程序计数器，多个线程共享同一个堆、方法区。这样的情况下我们就可以利用多线程为我们服务了。

多线程的应用场景

1. 提高我们网站系统的吞吐量
2. 分布式计算
3. 多线程的文件操作
4. 后台任务
5. 异步处理
6. 等等

线程的使用

一般简单的在Java中使用线程的话，我们大多数会采用一下几种方式：

方式一：继承于thread类

1. 创建一个继承于thread类的子类
2. 重写thread类的run()方法 ---->将此线程执行的操作声明在run（）中
3. 创建thread类的子类的对象
4. 通过此对象调用start（）
   1. 启动当前线程
   2. 调用当前线程的run()

public class Threads {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("hello");
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("Hi");
    }
}

方式二：实现runnable接口

1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable接口的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start（）
   1. 启动当前线程
   2. 调用当前线程的run() —>调用了runnable类型的target的run()

public class Threads {
    public static void main(String[] args) {
        MyThread threads = new MyThread();
        Thread thread= new Thread(threads);
        thread.start();
    }
}

class MyThread implements Runnable{
    
    @Override
    public void run() {
        System.out.println("Hi");
    }
}

方式三：实现Callable接口

1. 创建一个实现Callable的实现类
2. 实现call方法，将此线程要执行的操作声明在call（）中
3. 创建callable接口实现类的对象
4. 将此callable接口实现类的对象作为参数传递到FutureTask的构造器中，创建futureTask对象
5. 将futureTask对象作为参数传递到Thread类的构造器中，创建thread对象，并调用start方法
6. 获取Callable中call方法的返回值

public class CallableTest {
    public static void main(String[] args) {
        Num n = new Num();
        FutureTask futureTask = new FutureTask(n);

        new Thread(futureTask).start();

        try {
            //get返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
            Object o = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Num implements Callable{

    @Override
    public Object call() throws Exception {
        return 1;
    }
}

方式四：使用线程池

1. 提供指定线程数量的线程池
2. 执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
3. 关闭连接池

class Number implements Runnable{
    @Override
    public void run() {
        System.out.println("runnable");
    }
}

class Numbers implements Runnable{
    @Override
    public void run() {
        System.out.println("runnables");
    }
}

public class ThreadPoolTest {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = newFixedThreadPool(10);
        
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) service;
        //设置
//        threadPoolExecutor.setCorePoolSize(15);
//        threadPoolExecutor.setMaximumPoolSize(1);
//        threadPoolExecutor.setKeepAliveTime();
        
        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        //适合用于Callable接口
        //service.submit();
        //适合用于Runnable接口
        service.execute(new Number());
        service.execute(new Numbers());
        //3.关闭连接池
        service.shutdown();
    }
}

多线程经典面试题

1. 启动线程方法 start()和 run()有什么区别？

只有调用了 start()方法，才会表现出多线程的特性，不同线程的 run()方法里面的代码交替执行。如果只是调用 run()方法，那么代码还是同步执行的，必须等待一个线程的 run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其 run()方法里面的代码。

3. 一个线程的生命周期有哪几种状态？它们之间如何流转的？

NEW：毫无疑问表示的是刚创建的线程，还没有开始启动。
RUNNABLE: 表示线程已经触发 start()方式调用，线程正式启动，线程处于运行中状态。
BLOCKED：表示线程阻塞，等待获取锁，如碰到 synchronized、lock 等关键字占用临界区的情况，一旦获取到锁就进行 RUNNABLE 状态继续运行。
WAITING：表示线程处于无限制等待状态，等待一个特殊的事件来重新唤醒，如通过wait()方法进行等待的线程等待一个 notify()或者 notifyAll()方法，通过 join()方法进行等待的线程等待目标线程运行结束而唤醒，一旦通过相关事件唤醒线程，线程就进入了 RUNNABLE 状态继续运行。
TIMED_WAITING：表示线程进入了一个有时限的等待，如 sleep(3000)，等待 3 秒后线程重新进行 RUNNABLE 状态继续运行。
TERMINATED：表示线程执行完毕后，进行终止状态。需要注意的是，一旦线程通过 start 方法启动后就再也不能回到初始 NEW 状态，线程终止后也不能再回到RUNNABLE 状态