JUC学习之Java 线程常用方法

Posted 2022-01-03 大忽悠爱忽悠

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JUC学习之Java 线程常用方法相关的知识，希望对你有一定的参考价值。

JUC学习之Java 线程常用方法

Java 线程
查看进程线程的方法
线程运行原理
常用方法
不推荐使用的方法
主线程与守护线程
- 说法一: 线程的五种状态
- 说法二: 六种状态
总结

内容导读:

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

Java 线程

方法一，直接使用 Thread

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

example:

// 构造方法的参数是给线程指定名字，推荐
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();

example:

// 创建任务对象
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 精简代码

// 创建任务对象
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 类型的参数，用来处理有返回结果的情况

FutureTask本质就是继承了Runnable接口和Future接口，Future接口提供了很多额外的特性:

public interface Future<V> 
    /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, has already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when @code cancel is called,
     * this task should never run.  If the task has already started,
     * then the @code mayInterruptIfRunning parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     *
     * <p>After this method returns, subsequent calls to @link #isDone will
     * always return @code true.  Subsequent calls to @link #isCancelled
     * will always return @code true if this method returned @code true.
     *
     * @param mayInterruptIfRunning @code true if the thread executing this
     * task should be interrupted; otherwise, in-progress tasks are allowed
     * to complete
     * @return @code false if the task could not be cancelled,
     * typically because it has already completed normally;
     * @code true otherwise
     */
    boolean cancel(boolean mayInterruptIfRunning);
       /**
     * Returns @code true if this task was cancelled before it completed
     * normally.
     *
     * @return @code true if this task was cancelled before it completed
     */
    boolean isCancelled();
        /**
     * Returns @code true if this task completed.
     *
     * Completion may be due to normal termination, an exception, or
     * cancellation -- in all of these cases, this method will return
     * @code true.
     *
     * @return @code true if this task completed
     */
    boolean isDone();
        /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     */
    V get() throws InterruptedException, ExecutionException;
        /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

使用演示:

// 创建任务对象
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

查看进程线程的方法

windows

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

Java

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

linux

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

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（密码）

线程运行原理

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？

其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

栈帧图解

多线程

并且主线程的临时线程是不同的栈，即各自有各自的栈，来存放各自的栈帧(方法运行)

总结:每个线程有自己独立的栈内存，里面有多个栈帧，他们之间互不干扰，当所有线程执行完毕，程序结束

线程上下文切换（Thread Context Switch）

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念
就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

常用方法

start 与 run

调用 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 中的代码

sleep 与 yield

sleep

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

yield

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

让出当前cpu使用权，注意如果在让出cpu使用权时，此时没有其他线程需要执行，那么任务调度器会把cpu时间片分给这个线程，即继续执行当前yield的线程

任务调度器不会把时间片分给处于阻塞(休眠状态的线程)

线程优先级

线程优先级会提示（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();

应用:sleep方法来限制cpu的使用

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权给其他程序

while(true) 
 try 
 Thread.sleep(50);
  catch (InterruptedException e) 
 e.printStackTrace();

可以用 wait 或条件变量达到类似的效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep 适用于无需锁同步的场景

join 方法详解

为什么需要 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 行不行？为什么？----不知道确切的子线程结束时间，不太好把握
用 join，加在 t1.start() 之后即可

join()等待线程运行结束

join应用之同步

以调用方角度来讲，如果

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

等待多个结果

问，下面代码 cost 大约多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException 
 test2();

private static void test2() throws InterruptedException 
 Thread t1 = new Thread(() -> 
 sleep(1);
 r1 = 10;
 );
 Thread t2 = new Thread(() -> 
 sleep(2);
 r2 = 20;
 );
 long start = System.currentTimeMillis();
 t1.start();
 t2.start();
 t1.join();
 t2.join();
 long end = System.currentTimeMillis();
 log.debug("r1:  r2:  cost: ", r1, r2, end - start);

分析如下

第一个 join：等待 t1 时, t2 并没有停止, 而在运行
第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

如果颠倒两个 join 呢？

最终都是输出

20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005

有时效的 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 以上是关于JUC学习之Java 线程常用方法的主要内容，如果未能解决你的问题，请参考以下文章 
 JUC学习之共享模型上
 JUC学习之共享模型之工具上之线程池浅学
 JUC学习之不可变
 JUC学习之线程安全集合类
 JAVA基础学习之-AQS的实现原理分析
 JUC学习之预热知识