高并发学习之02线程基础知识

1.什么情况下应该使用多线程

线程出现的目的是什么？解决进程中多任务的实时性问题？其实简单来说，也就是解决“阻塞”的问题，阻塞的意思就是程序运行到某个函数或过程后等待某些事件发生而暂时停止 CPU 占用的情况，也就是说会使得 CPU 闲置。还有一些场景就是比如对于一个函数中的运算逻辑的性能问题，我们可以通过多线程
的技术，使得一个函数中的多个逻辑运算通过多线程技术达到一个并行执行，从而提升性能。
所以，多线程最终解决的就是“等待”的问题。
简单总结的使用场景

• 通过并行计算提高程序执行性能
• 需要等待网络、I/O 响应导致耗费大量的执行时间，可以采用异步线程的方式来减少阻塞

2.如何应用多线程

在 Java 中，有多种方式来实现多线程。继承 Thread 类、实现 Runnable 接口、使用 ExecutorService、Callable、Future 实现带返回结果的多线程。

2.1 继承Thread类创建线程

Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个native 方法，它会启动一个新线程，并执行 run()方法。这种方式实现多线程很简单，通过自己的类直接 extend Thread，并复写 run()方法，就可以启动新线程并执行自己定义的 run()方法。

public class MyThread extends Thread {
	public void run() {
	System.out.println("MyThread.run()");
	}
}
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

2.2 实现Runnable 接口创建线程

如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，
可以实现一个 Runnable 接口

public class MyThread extends OtherClass implements Runnable {
	public void run() {
	System.out.println("MyThread.run()");
	}
}

2.3 实现 Callable接口通过FutureTask来创建Thread线程

有的时候，我们可能需要让一步执行的线程在执行完成以后，提供一个返回值给到当前的主线程，主线程需要依赖这个值进行后续的逻辑处理，那么这个时候，就需要用到带返回值的线程了。Java 中提供了这样的实现方式：

public class CallableDemo implements Callable<String> {

		public static void main(String[] args) throws ExecutionException,InterruptedException{
			ExecutorService executorService=Executors.newFixedThreadPool(1);
			CallableDemo callableDemo=new CallableDemo();
			Future<String> future=executorService.submit(callableDemo);
			System.out.println(future.get());
			executorService.shutdown();
		}
		
		@Override
		public String call() throws Exception {
			int a=1;
			int b=2;
			System.out.println(a+b);
			return "执行结果:"+(a+b);
		}
}

3.线程的6中状态

Java 线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，线程一共有 6 种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）

• . NEW：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
• . RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”
• . BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况：
  1. 等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列
  2. 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中
  3. 其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复
• WATING: 等待线程的状态
• TIME_WAITING：超时等待状态，超时以后自动返回
• TERMINATED：终止状态，表示当前线程执行完毕

4.Daemon(守护进程)线程

在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这
意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。说白了所谓守护 线程，就是在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。

public class DaemonDemo {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                System.out.println("我是守护线程");
            }
        });
        thread.setDaemon(true);
        thread.start();
    }
}

需要注意的是：

• thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
• 在Daemon线程中产生的新线程也是Daemon的。
• 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。

5.线程启动和终止

5.1 先看看线程初始化

下面这段代码是Thread 类构造函数中初始化的逻辑

	/**
     * Initializes a Thread. 初始化一个线程。
     *
     * @param g the Thread group			线程组（null）
     * @param target the object whose run() method gets called 要执行的Runnable逻辑
     * @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.
     * 新线程所需的堆栈大小 0表示该参数将被忽略
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     */
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name.toCharArray();
		//当前线程就是该线程的父线程
        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 doesn't have a strong opinion of 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(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();
		//将daemon、priority属性设置为父线程的对应属性
        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);
        // 将父线程的InheritableThreadLocal复制过来
        if (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 分配一个线程ID*/
        tid = nextThreadID();
    }

在上述过程中，一个新构造的线程对象是由其parent线程来进行空间分配的，而child线程
继承了parent是否为Daemon、优先级和加载资源的contextClassLoader以及可继承的
ThreadLocal，同时还会分配一个唯一的ID来标识这个child线程。至此，一个能够运行的线程对
象就初始化好了，在堆内存中等待着运行。

5.2 线程启动

在我们上面的例子中，线程调用start()方法就可以启动线程了。其实就是通过父线程告诉JVM，当前线程参与CPU的竞争，如果争抢到了，就运行当前线程。

5.3 中断线程

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行
了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()
方法对其进行中断操作。
线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否
被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。

通过下面这个例子，来实现了线程终止的逻辑

public class InterruptDemo {
	private static int i;
	public static void main(String[] args) throws InterruptedException {
		Thread thread=new Thread(new Runnable(){
			  public void run() {
                while(!Thread.currentThread().isInterrupted()){
                    i++;
                }
                System.out.println("Num:"+i);
            }
		},"interruptDemo");
		thread.start();
		TimeUnit.SECONDS.sleep(1);
		thread.interrupt();
	}
}

通过下面的例子来展示对当前线程的中断标识位进行复位。

public class InterruptDemo {
	public static void main(String[] args) throws InterruptedException{
		Thread thread=new Thread(()->{
			while(true){
				boolean ii=Thread.currentThread().isInterrupted();
				if(ii){
					System.out.println("before:"+ii);
					Thread.interrupted();//对线程进行复位，中断标识为false
					System.out.println("after:"+Thread.currentThread().isInterrupted());
				}
			}
		});
		thread.start();
		TimeUnit.SECONDS.sleep(1);
		thread.interrupt();//设置中断标识,中断标识为 true
	}
}

如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。
从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(long
millis)方法）这些方法在抛出InterruptedException之前，Java虚拟机会先将该线程的中断标识位
清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false。

5.4 suspend()、resume()和stop()中断线程

public class Deprecated {
    public static void main(String[] args) throws Exception {
        DateFormat format = new SimpleDateFormat("HH:mm:ss");
        Thread printThread = new Thread(new Runner(), "PrintThread");
        printThread.setDaemon(true);
        printThread.start();
        TimeUnit.SECONDS.sleep(3);
        // 将PrintThread进行暂停，输出内容工作停止
        printThread.suspend();
        System.out.println("main suspend PrintThread at " + format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);
        // 将PrintThread进行恢复，输出内容继续
        printThread.resume();
        System.out.println("main resume PrintThread at " + format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);
        // 将PrintThread进行终止，输出内容停止
        printThread.stop();
        System.out.println("main stop PrintThread at " + format.format(new Date()));
        TimeUnit.SECONDS.sleep(3);
    }
    static class Runner implements Runnable {
        @Override
        public void run() {
            DateFormat format = new SimpleDateFormat("HH:mm:ss");
            while (true) {
                System.out.println(Thread.currentThread().getName() + " Run at " +
                        format.format(new Date()));
                SleepUtils.second(1);
            }
        }
    }
}

在执行过程中，PrintThread运行了3秒，随后被暂停，3秒后恢复，最后经过3秒被终止。
通过示例的输出可以看到，suspend()、resume()和stop()方法完成了线程的暂停、恢复和终
止工作，而且非常“人性化”。但是这些API是过期的，也就是不建议使用的。
不建议使用的原因主要有：以suspend()方法为例，在调用后，线程不会释放已经占有的资
源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop()方法在终结
一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，
因此会导致程序可能工作在不确定状态下。
所以interrupted这种通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法与suspend和stop比显得更加安全和优雅。