并发编程第三章线程创建、原理、常用线程方法

并发编程

3.Java线程

本章内容

• 创建和运行线程
• 查看线程
• 线程API
• 线程状态

3.1创建和运行线程

方法一：直接使用thread

// 创建线程对象
Thread t = new Thread() {
  public void run() {
      // 要执行的任务
     }
};
// 启动线程
t.start();

例如：

// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
 	@Override
 	// run 方法内实现了要执行的任务
 	public void run() {
 		log.debug("hello");
	 }
};
t1.start();

输出：

19:19:00 [t1] c.ThreadStarter - hello

方法二：使用Runnable配合Thread

把【线程】和【任务】（要执行的代码）分开

• Thread 代表线程
• Runnable 可运行的任务（线程要执行的代码）

Runnable runnable = new Runnable() {
 	public void run(){
 		// 要执行的任务
	 }
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start(); 

例如：

// 创建任务对象
Runnable task2 = new Runnable() {
 	@Override
 	public void run() {
 		log.debug("hello");
 	}
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

输出：

19:19:00 [t2] c.ThreadStarter - hello

Java 8 以后可以使用 lambda 精简代码,lambda表达式实际上就是创建了一个对线，即使用lambda可以实现对对象的创建进行简化

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

** 原理之Thread 与 Runnable 的关系**
分析 Thread 的源码，理清它与 Runnable 的关系

小结

• 方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
• 用 Runnable 更容易与线程池等高级 API 配合
• 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

方法三：FutureTask配合Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

注意：Java接口可以支持继承多个接口，可以具体看下Java中接口的多继承和类的单继承，基础部分知识也需要打牢

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
	 log.debug("hello");
	 return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

输出:

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

3.2观察多个线程同时运行

主要是理解

• 交替执行
• 谁先谁后，不由我们控制

3.3查看进程线程的方法

windows

• 任务管理器可以查看进程和线程数，也可以用来杀死进程
• tasklist 查看进程
• taskkill 杀死进程

linux

• ps -fe 查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill 杀死进程
• top 按大写 H 切换是否显示线程
• top -H -p 查看某个进程（PID）的所有线程

Java

• jps 命令查看所有 Java 进程
• jstack 查看某个 Java 进程（PID）的所有线程状态
• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

jconsole 远程监控配置

• 需要以如下方式运行你的 java 类
  -- java -Djava.rmi.server.hostname=ip地址 -Dcom.sun.management.jmxremote -
  Dcom.sun.management.jmxremote.port=连接端口 -Dcom.sun.management.jmxremote.ssl=是否安全连接 -Dcom.sun.management.jmxremote.authenticate=是否认证 java类
• 修改 /etc/hosts 文件将 127.0.0.1 映射至主机名

如果要认证访问，还需要做如下步骤

• 复制 jmxremote.password 文件
• 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
• 连接时填入 controlRole（用户名），R&D（密码）
  这部分知识需要学习jvm时继续补充：
  JConsole可视化工具介绍
  JVM性能调优监控工具jps、jmap、jstack、jstat使用详解

3.4原理之线程运行

栈与栈帧
Java Virtual Machine Stacks （Java 虚拟机栈）
我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟
机就会为其分配一块栈内存。

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存，即每调用一次方法，则产生一个栈帧
• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法
  
  栈帧图解，p11章节需要重点看下
  
  线程运行原理，多线程：
  多个线程之间的栈内存是互相独立的，互不干扰
  IntelliJ IDEA - Debug 调试多线程程序
  多线程调测方法，可以学下，很有用
  线程上下文切换（Thread Context Switch）
  因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码
• 线程的 cpu 时间片用完
• 垃圾回收
• 有更高优先级的线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法
  当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念
  就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的
• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• Context Switch 频繁发生会影响性能

3.5常见方法

3.6start方法详解

调用run

public static void main(String[] args) {
 	Thread t1 = new Thread("t1") {
 		@Override
 		public void run() {
 		log.debug(Thread.currentThread().getName());
 		FileReader.read(Constants.MP4_FULL_PATH);
 		}
 	};
 t1.run();
 log.debug("do other things ...");
}

输出：

19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...

程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

调用start
将上述代码的 t1.run() 改为t1.start();
输出:

19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

程序在 t1 线程运行， FileReader.read() 方法调用是异步的
小结：

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程
• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

3.7yield与sleep

sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程(但是cpu可能还是会选择到此线程继续执行)
2. 具体的实现依赖于操作系统的任务调度器

线程优先级

• 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
• 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

 Runnable task1=()->{
      int count=0;
      for(;;){
          System.out.println("---->1 "+count++);
      }
 };
 Runnable task2=()->{
     int count=0;
      for(;;){
          // Thread.yield();
           System.out.println(" ---->2 "+count++);
      }
 };
 Thread t1=new Thread(task1,"t1");
 Thread t2=new Thread(task2,"t2");
 // t1.setPriority(Thread.MIN_PRIORITY);
 // t2.setPriority(Thread.MAX_PRIORITY);
 t1.start();
 t2.start();

3.8join方法详解

为什么需要join

下面的代码执行，打印 r 是什么？

    static int r = 0;

    public static void main(String[] args) throws InterruptedException {
        test1();
    }

    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        });
        t1.start();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }

分析：

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

• 用 sleep 行不行？也可以，但是不太好；为什么？需要主线程等待到t1线程结束才可以
• 用 join，加在 t1.start() 之后即可

应用之同步
以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步
  

有时效的join

等够时间

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
 test3();
}
public static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 sleep(1);
 r1 = 10;
 });
 long start = System.currentTimeMillis();
 t1.start();
// 线程执行结束会导致 join 结束
 t1.join(1500);
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

输出:

20:48:01.320 [main] c.TestJoin - r1: 10 r2: 0 cost: 1010
没等够时间

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
 test3();
}
public static void test3() throws InterruptedException {
 Thread t1 = new Thread(() -> {
 sleep(2);
 r1 = 10;
 });
 long start = System.currentTimeMillis();
 t1.start();
 // 线程执行结束会导致 join 结束
 t1.join(1500);
 long end = System.currentTimeMillis();
 log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

输出：

20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502

3.9interrupt方法详解

打断 sleep，wait，join 的线程
这几个方法都会让线程进入阻塞状态
打断 sleep 的线程, 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
 Thread t1 = new Thread(()->{
 sleep(1);
 }, "t1");
 t1.start();
 sleep(0.5);
 t1.interrupt();
 log.debug(" 打断状态: {}", t1.isInterrupted());
}

输出:

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 cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
 at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
 at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

打断正常运行的线程
打断正常运行的线程, 不会清空打断状态

private static void test2() throws InterruptedException {
 Thread t2 = new Thread(()->{
 while(true) {
 Thread current = Thread.currentThread();
 boolean interrupted = current.isInterrupted();
 if(interrupted) {
 log.debug(" 打断状态: {}", interrupted);
 break;
 }
 }
 }, "t2");
 t2.start();
 sleep(0.5);
 t2.interrupt();
}

输出:
20:57:37.964 [t2] c.TestInterrupt - 打断状态: true

3.9.1终止模式之两阶段终止模式

Two Phase Termination
在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。
1. 错误思路

• 使用线程对象的 stop() 方法停止线程
  -- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁
• 使用 System.exit(int) 方法停止线程
  -- 目的仅是停止一个线程，但这种做法会让整个程序都停止

2. 两阶段终止模式

在1阶段如果有异常，属于正常运行过程中被打断，打断标记为true,判断有没有被打断，结果为是，会走向料理后事的步骤；
在睡眠过程中有异常，2阶段，属于阻塞阶段线程被打断，线程抛出异常后，会走异常逻辑，并且打断标记被会被重新置为false,如果需要保证被打断后，标记仍为true，需要手动进行重置。
2.1 利用 isInterrupted
interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

class TPTInterrupt {
    private Thread thread;

    public void start() {
        thread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    current.interrupt();
                }
                // 执行监控操作                           
            }
        }, "监控线程");
        thread.start();
    }

    public void stop() {
        thread.interrupt();
    }
}

调用

    TPTInterrupt t = new TPTInterrupt(); 
    t.start();
    Thread.sleep(3500);
    log.debug("stop"); 
    t.stop();

结果

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存 
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存 
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存 
11:49:45.413 c.TestTwoPhaseTermination [main] - stop 
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

2.2 利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;

    public void start() {
        thread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                }                // 执行监控操作            
            }
        }, "监控线程");
        thread.start();
    }

    public void stop() {
        stop = true;
        thread.interrupt();
    }
}

调用：

TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500); 
log.debug("stop"); t.stop();

结果：

11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存 11:54:53.006 
c.TPTVolatile [监控线程] - 将结果保存 11:54:54.007 
c.TPTVolatile [监控线程] - 将结果保存 11:54:54.502
 c.TestTwoPhaseTermination [main] - stop 
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

4.0 interruot打断park线程

interrupt方法可以打断调用park后的线程，使得程序继续向下执行

需要注意的是，park方法后调用interrupt,会将打断标记设置为true,后续再调用park方法，将不再生效(如果想park方法继续生效，需要调用interrupted将打断标记重置为false,)，不能阻止程序继续向下执行。

4.1不再推荐使用的方法

4.2守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守
护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
 log.debug("开始运行...");
 sleep(2);
 log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

输出：

08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束... 

注意：

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的 Acceptor(接收请求) 和 Poller(分发请求) 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求
• 我们熟知的main线程默认情况下并不是守护线程，并不会等待子线程的结束。