并发编程一、多线程的意义和使用

目录

• 一、相关概念
  • 1. 影响服务器吞吐量的因素
  • 2. 进程与线程
  • 3. 并发和并行
• 二、线程的应用
  • 1. 线程创建
• 三、线程的生命周期
  • 1. 代码演示线程的几种状态
  • 2. 线程的生命周期
  • 3. 线程的启动
  • 4. 线程的终止

一、相关概念

1. 影响服务器吞吐量的因素

  硬件方面：CPU、内存、磁盘、网络
  软件层面：硬件资源是前提，软件层面的配置是为了最大化的利用硬件资源，如配置 线程数量、JVM内存分配大小、网络通信机制(BIO/NIO/AIO)、磁盘IO
从计算机本身的角度来考虑的话，一个请求的访问到处理最终到返回，性能瓶颈只会是：CPU、文件IO、网络IO、内存、等因素。而一台计算机中这些纬度是有性能瓶颈的 ，如果某个资源消耗过多，通常会造成系统的响应速度较慢，所以增加一台机器使得数据库的IO和CPU资源独占一台机器从而增加性能。

各个资源的消耗原因
CPU/IO/内存
1. CPU，主要是上下文的切换，因为每个CPU核心在同一时刻只能执行一个线程，而CPU的调度有几种方式，比如抢占式和轮询等，以抢占式为例，每个线程会分配一定的执行时间，当达到执行时间、线程中有IO阻塞或者有高优先级的线程要执行时。CPU会切换执行其他线程。而在切换的过程中，需要存储当前线程的执行状态并恢复要执行的线程状态，这个过程就是上下文切换。比如IO、锁等待等场景下也会触发上下文切换，当上下文切换过多时会造成内核占用比较多的CPU。
2. 文件IO，比如频繁的日志写入，磁盘本身的处理速度较慢、都会造成IO性能问题
3. 网络IO，带宽不够
4. 内存，包括内存溢出、内存泄漏、内存不足
实际上不管是应用层的调优也好，还是硬件的升级也好。其实无非就是这几个因素的调整。

2. 进程与线程

对比	进程	线程
定义	进程是程序运行的一个实体的运行过程，是系统进行资源分配和调配的一个独立单位	线程是进程运行和执行的最小调度单位
包含关系	一个进程内有1到N个线程	线程是进程的一部分，也被称为轻量级的进程
系统开销	创建撤销切换开销大，资源要重新分配和收回	仅保存少量寄存器的内容，开销小，在进程的地址空间执行代码
拥有资产	资源拥有的基本单位	基本上不占资源，仅有不可少的资源（程序计数器，一组寄存器和栈）
调度	资源分配的基本单位	独立调度分配的单位
安全性	进程间相互独立，互不影响	线程共享一个进程下面的资源，可以互相通信和影响
地址空间	系统赋予的独立的内存地址空间	由相关堆栈寄存器和和线程控制表TCB组成，寄存器可被用来存储线程内的局部变量

3. 并发和并行

  并行：指两个或多个事件在同一时刻发生

  并发：指两个或多个事件在同一时间间隔内发生。以单核CPU的电脑为例，如果它是以多线程运行的，CPU是通过不断分配时间片的方式来实现线程切换，只是线程之间切换的速度太快我们难以察觉。

二、线程的应用

1. 线程创建

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

public class MyThread extends Thread {

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + " is running");

    }

    public static void main(String[] args) {

        Thread thread = new MyThread();
        thread.start();

    }

}

  实现Runnable接口、

public class MyRunnable implements Runnable {

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + " is running");

    }

    public static void main(String[] args) {

        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }

}

  使用ExecutorService、Callable、Future实现带返回结果的多线程

import java.util.concurrent.*;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {

        String str = Thread.currentThread().getName() + " is running";
        return str;
    }

    public static void main(String[] args) {

        ExecutorService pool = Executors.newFixedThreadPool(1);
        Future<String> future = pool.submit(new MyCallable());

        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        pool.shutdown();

    }

}

三、线程的生命周期

1. 代码演示线程的几种状态

  首先分别创建几种情况的线程，然后使用jps、jstack命令分别查看该进程pid下的线程的状态。
  4个不同的线程：Thread_Status_01：休眠一定时间；Thread_Status_02: 等待；Thread_Status_03和Thread_Status_04: 两个线程同时抢占一个对象锁，所以其中会有一个线程一定没有抢到锁；

import java.util.concurrent.TimeUnit;

public class ThreadStatus {

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {

                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }, "Thread_Status_01").start();

        new Thread(() -> {
            while (true) {
                synchronized (ThreadStatus.class) {
                    try {
                        ThreadStatus.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "Thread_Status_02").start();


        BlockedDemo blockedDemo = new BlockedDemo();

        new Thread(() -> {
            blockedDemo.test();
        }, "Thread_Status_03").start();

        new Thread(() -> {
            blockedDemo.test();
        }, "Thread_Status_04").start();

    }


}

class BlockedDemo {

    public void test() {

        synchronized (this) {

            while (true) {

                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }

    }

}

  命令行或Intellij Idea中右键Open In Terminal在IDE中打开命令行，输入jps查看demo对应的进程pid，可以看到ThreadStatus所对应进程pid为15516，

  之后，使用JVM工具jstack来查看该pid下的信息，找出定义的4个线程及其对应状态；windows下也可以使用jvisualvm命令来打开Java VisualVM可视化工具找到对应pid的线程信息，导出线程 Dump来查看线程信息

E:......igshen-threads-bootsrcmainjavacomigshen	hreads>jstack 15516

Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.111-b14 mixed mode):

"DestroyJavaVM" #16 prio=5 os_prio=0 tid=0x00000000030e3800 nid=0x3ee8 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Thread_Status_04" #15 prio=5 os_prio=0 tid=0x000000001fbfa000 nid=0x3f8c waiting for monitor entry [0x00000000204ff000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.bigshen.threads.BlockedDemo.test(ThreadStatus.java:61)
        - waiting to lock <0x000000076bc86e90> (a com.bigshen.threads.BlockedDemo)
        at com.bigshen.threads.ThreadStatus.lambda$main$2(ThreadStatus.java:44)
        at com.bigshen.threads.ThreadStatus$$Lambda$3/769287236.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)

"Thread_Status_03" #14 prio=5 os_prio=0 tid=0x000000001fbef000 nid=0x168c waiting on condition [0x00000000203fe000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Thread.java:340)
        at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
        at com.bigshen.threads.BlockedDemo.test(ThreadStatus.java:61)
        - locked <0x000000076bc86e90> (a com.bigshen.threads.BlockedDemo)
        at com.bigshen.threads.ThreadStatus.lambda$main$1(ThreadStatus.java:40)
        at com.bigshen.threads.ThreadStatus$$Lambda$2/2046562095.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)

"Thread_Status_02" #13 prio=5 os_prio=0 tid=0x000000001fbee800 nid=0x38d0 in Object.wait() [0x00000000202ff000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x000000076b823090> (a java.lang.Class for com.bigshen.threads.ThreadStatus)
        at java.lang.Object.wait(Object.java:502)
        at com.bigshen.threads.ThreadStatus.lambda$main$0(ThreadStatus.java:28)
        - locked <0x000000076b823090> (a java.lang.Class for com.bigshen.threads.ThreadStatus)
        at com.bigshen.threads.ThreadStatus$$Lambda$1/214126413.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:745)

"Thread_Status_01" #12 prio=5 os_prio=0 tid=0x000000001ee5f800 nid=0x3dfc waiting on condition [0x000000001f9ff000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at com.bigshen.threads.ThreadStatus$1.run(ThreadStatus.java:15)
        at java.lang.Thread.run(Thread.java:745)

"Service Thread" #11 daemon prio=9 os_prio=0 tid=0x000000001edab800 nid=0xd68 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE
   
....

  可以看到：线程Thread_Status_01为TIMED_WAITING 超时等待状态、线程Thread_Status_02为WAITING 等待状态、
  线程Thread_Status_03为TIMED_WAITING 超时等待状态，表明线程3已结执行了sleep方法，获得了锁、
  线程Thread_Status_04为BLOCKED 阻塞状态，因为线程4和线程3再抢夺同一个对象锁，线程3获得了锁，线程4阻塞。

2. 线程的生命周期

  Java线程既然能够创建，势必也能被销毁，所以线程是存在生命周期的。
  线程一共有6种状态新建(NEW)、运行(RUNNABLE)、超时等待(TIMED_WAITING)、等待(WAITING)、阻塞(BLOCKED)、终止(TERMINATED)

3. 线程的启动

  线程的启动并不是直接调用run()方法，而是调用start()方法，源码中可以看到真正调用的是native的start0()方法，底层为C语言的逻辑实现。

  private native void start0(); 

4. 线程的终止

  线程的终止也并不是简单的调用stop()命令，首先它是一个过期的方法，根本原因是stop方法在结束一个线程时并不会保证线程的资源正常释放，因此会导致程序可能出现一些不确定的状态。
  要去优雅的中断一个线程，在线程中提供了一个interrupt()方法。底层调用的是native的interrupt0()方法，同样为C语言实现。

  private native void interrupt0(); 

  下面以三个demo来演示线程的终止。
  样例1：主线程创建线程Thread_end_demo，该线程内部根据线程是否是终止状态来决定是否继续执行；然后主线程在休眠100毫秒后终止Thread_end_demo线程。

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class ThreadEndDemo implements Runnable {

    @Override
    public void run() {

//        while (true) {
        while (!Thread.currentThread().isInterrupted()) {
            // do something
            System.out.println(Thread.currentThread().getName() + " ----  " + Thread.currentThread().isInterrupted() + " -----  " + new Date());
        }

    }

    public static void main(String[] args) {

        Thread thread = new Thread(new ThreadEndDemo(), "Thread_end_demo");

        thread.start();
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("set child thread interrupt at" + new Date());
        thread.interrupt();

    }

}

运行结果
...
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019
set child thread interrupt atMon May 18 10:41:46 CST 2019
Thread_end_demo ----  false -----  Mon May 18 10:41:46 CST 2019

  可以看到在主线程调用子线程的interrupt()方法进行终止后，子线程成功终止。

  样例2：
  演示当主线程终止子线程时，子线程如果是休眠状态能否成功终止？

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class ThreadEndDemo2 implements Runnable {

    @Override
    public void run() {

        while (!Thread.currentThread().isInterrupted()) {

            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " throw InterruptedException : " + e + ";  at " + new Date());
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " ---------- " + Thread.currentThread().isInterrupted() + " ----  " + new Date());
        }

    }

    public static void main(String[] args) {

        Thread thread = new Thread(new ThreadEndDemo2(), "Thread_end_demo");

        thread.start();

        System.out.println("main thread start sleep 3s at " + new Date());
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main thread wakeup, set child thread interrupt at" + new Date());
        thread.interrupt();

    }

}

···运行结果
main thread start sleep 3s at Mon May 18 10:59:07 CST 2019
main thread wakeup, set child thread interrupt atMon May 18 10:59:10 CST 2019
Thread_end_demo throw InterruptedException : java.lang.InterruptedException: sleep interrupted;  at Mon May 18 10:59:10 CST 2019
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.bigshen.threads.end.ThreadEndDemo2.run(ThreadEndDemo2.java:14)
	at java.lang.Thread.run(Thread.java:745)
Thread_end_demo ---------- false ----  Mon May 18 10:59:10 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 10:59:20 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 10:59:30 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 10:59:40 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 10:59:50 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 11:00:00 CST 2019
Thread_end_demo ---------- false ----  Mon May 18 11:00:10 CST 2019..
...

  可以看到，当线程Thread_end_demo是在休眠状态下时，如果主线程尝试将其终止，子线程会收到该终止指令并抛出 InterruptedException，但并不会真正将线程终止，而且子线程的isInterrupted()状态也被重置为了false。由此可以推断抛出的InterruptedException会触发线程状态的复位，即将interrupt状态重新改为false。这里其实从hotspot底层jvm源码中可以看出,不再继续展开。
  其实这里设计的意思已经很明显了：如果一个线程处于休眠状态时被终止，因为该线程可能在休眠后还有其余业务逻辑需要执行，这个需要交由子线程自己去判断。所以系统并不会直接终止该线程，而是会将该线程唤醒并抛出InterruptedException异常，交由子线程自己来判断是立刻终止、处理完一些业务后终止、还是不终止。
  样例3： 当线程处于休眠状态下时进行终止

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class ThreadEndDemo2 implements Runnable {

    @Override
    public void run() {

        while (!Thread.currentThread().isInterrupted()) {

            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                // 抛出InterruptedException异常，底层实现会触发线程 interrupt 状态复位
                System.out.println(Thread.currentThread().getName() + " -------- " + Thread.currentThread().isInterrupted() + "; throw InterruptedException : " + e + ";  at " + new Date());
//                e.printStackTrace();

                //TODO do something

                // 终止线程
                Thread.currentThread().interrupt();
            }
            System.out.println(Thread.currentThread().getName() + " ---------- " + Thread.currentThread().isInterrupted() + " ----  " + new Date());
        }

    }

    public static void main(String[] args) {

        Thread thread = new Thread(new ThreadEndDemo2(), "Thread_end_demo");

        thread.start();

        System.out.println("main thread start sleep 3s at " + new Date());
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main thread wakeup, set child thread interrupt at" + new Date());
        thread.interrupt();

    }

}

... 运行结果
main thread start sleep 3s at Mon May 18 11:19:53 CST 2019
main thread wakeup, set child thread interrupt atMon May 18 11:19:56 CST 2019
Thread_end_demo -------- false; throw InterruptedException : java.lang.InterruptedException: sleep interrupted;  at Mon May 18 11:19:56 CST 2019
Thread_end_demo ---------- true ----  Mon May 18 11:19:56 CST 2019

Process finished with exit code 0

  此例子在InterruptedException异常中将线程重新设置为终止状态。成功将线程终止。