JUC (二) --------- Java 线程

朴灿烈づ我的快乐病毒、 2024-04-03 11:53 44阅读 0赞

#### 目录 ####

*  一、 创建和运行线程
 *   *  1. 直接使用 Thread
     *  2. 使用 Runnable 配合 Thread
     *  3. FutureTask 配合 Thread
 *  二、查看进程线程的方法
 *  三、线程运行原理
 *  四、常见方法
 *  五、start 与 run
 *  六、sleep 与 yield
 *  七、join 方法详解
 *  八、interrupt 方法详解
 *  九、不推荐的方法
 *  十、主线程与守护线程
 *  十一、五种状态
 *  十二、六种状态

--------------------

## 一、 创建和运行线程 ##

### 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

### 2. 使用 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 精简代码：

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

**原理之 Thread 与 Runnable 的关系**

Thread 和 Runnable 的实质是继承关系，没有可比性。无论使用 Runnable 还是 Thread，都会new Thread，然后执行 run 方法。用法上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现 runnable。

**小结**

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

### 3. FutureTask 配合 Thread ###

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

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

## 二、查看进程线程的方法 ##

**A、windows**

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

`tasklist`： 查看进程  
`taskkill`： 杀死进程

**B、linux**

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

**C、Java**

`jps`命令查看所有 Java 进程  
`jstack <PID>` 查看某个 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 (密码)

## 三、线程运行原理 ##

**A、栈与栈帧**

Java Virtual Machine Stacks (Java 虚拟机栈)

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

*  每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
 *  每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

**B、线程上下文切换 (Thread Context Switch)**

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

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

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

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

## 四、常见方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>static</th> 
   <th>功能说明</th> 
   <th>注意</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>start()</td> 
   <td></td> 
   <td>启动一个新线程，在新的线程运行 run 方法中的代码</td> 
   <td>start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次会出现 llegalThreadStateException</td> 
  </tr> 
  <tr> 
   <td>run()</td> 
   <td></td> 
   <td>新线程启动后会调用的方法</td> 
   <td>如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为</td> 
  </tr> 
  <tr> 
   <td>join()</td> 
   <td></td> 
   <td>等待线程运行结束</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>join(long n)</td> 
   <td></td> 
   <td>等待线程运行结束,最多等待 n 毫秒</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>getId()</td> 
   <td></td> 
   <td>获取线程长整型的 id</td> 
   <td>id 唯一</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td></td> 
   <td>获取线程名</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>setName(String)</td> 
   <td></td> 
   <td>修改线程名</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>getPriority()</td> 
   <td></td> 
   <td>获取线程优先级</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>setPriority(int)</td> 
   <td></td> 
   <td>修改线程优先级</td> 
   <td>java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率</td> 
  </tr> 
  <tr> 
   <td>getState()</td> 
   <td></td> 
   <td>获取线程状态</td> 
   <td>Java 中线程状态是用 6 个 enum 表示，分别为：NEW, RUNNABLE, BLOCKED, WAITING,TIMED_WAITING, TERMINATED</td> 
  </tr> 
  <tr> 
   <td>isInterrupted()</td> 
   <td></td> 
   <td>判断是否被打断</td> 
   <td>不会清除，打断标记</td> 
  </tr> 
  <tr> 
   <td>isAlive()</td> 
   <td></td> 
   <td>线程是否存活（还没有运行完毕）</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>interrupt()</td> 
   <td></td> 
   <td>打断线程</td> 
   <td>如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除 打断标记 ；如果打断的正在运行的线程，则会设置 打断标记 ；park 的线程被打断，也会设置 打断标记</td> 
  </tr> 
  <tr> 
   <td>interrupted()</td> 
   <td>static</td> 
   <td>判断当前线程是否被打断</td> 
   <td>会清除 打断标记</td> 
  </tr> 
  <tr> 
   <td>currentThread()</td> 
   <td>static</td> 
   <td>获取当前正在执行的线程</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>sleep(long n)</td> 
   <td>static</td> 
   <td>让当前执行的线程休眠n毫秒，休眠时让出 cpu的时间片给其它线程</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>yield()</td> 
   <td>static</td> 
   <td>提示线程调度器让出当前线程对CPU的使用</td> 
   <td>主要是为了测试和调试</td> 
  </tr> 
 </tbody> 
</table>

## 五、start 与 run ##

run() 只是在当前线程中执行任务，而 start 才是真正生成 thread，并放在cpu中调度。

**A、调用 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() 方法调用还是同步的。

**B、调用 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() 方法调用是异步的。

**C、结论**

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

## 六、sleep 与 yield ##

**A、sleep**

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

**B、yield**

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

**C、线程优先级**

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

## 七、join 方法详解 ##

join 这个方法的作用是先将当前线程挂起，待其他线程结束后在执行当前线程的代码。  
**A、为什么需要 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() 之后即可

**以调用方角度来讲，如果**

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

![在这里插入图片描述][49a9b92f74394dbdb2fc009a1f890a97.png]  
**等待多个结果**

问，下面代码 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

![在这里插入图片描述][53b3e2bc94c1453da736edbd06f74615.png]  
**B、有时效的 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

## 八、interrupt 方法详解 ##

interrupt 方法可以打断 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

**打断 park 线程**

打断 park 线程, 不会清空打断状态

private static void test3() throws InterruptedException {
        
    	Thread t1 = new Thread(() -> {
        
    		log.debug("park...");
    		LockSupport.park();
    		log.debug("unpark...");
    		log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    	}, "t1");
    	t1.start();
    	sleep(0.5);
    	t1.interrupt();
    }

输出

21:11:52.795 [t1] c.TestInterrupt - park...
    21:11:53.295 [t1] c.TestInterrupt - unpark...
    21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

如果打断标记已经是 true, 则 park 会失效

private static void test4() {
        
    	Thread t1 = new Thread(() -> {
        
    		for (int i = 0; i < 5; i++) {
        
    			log.debug("park...");
    			LockSupport.park();
    			log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    		}
    	});
    	t1.start();
    	sleep(1);
    	t1.interrupt();
    }

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park...
    21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true
    21:13:49.812 [Thread-0] c.TestInterrupt - park...
    21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
    21:13:49.813 [Thread-0] c.TestInterrupt - park...
    21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
    21:13:49.813 [Thread-0] c.TestInterrupt - park...
    21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
    21:13:49.813 [Thread-0] c.TestInterrupt - park...
    21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true

> 提示：可以使用 Thread.interrupted() 清除打断状态

## 九、不推荐的方法 ##

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>static</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>stop()</td> 
   <td></td> 
   <td>停止线程运行</td> 
  </tr> 
  <tr> 
   <td>suspend()</td> 
   <td></td> 
   <td>挂起（暂停）线程运行</td> 
  </tr> 
  <tr> 
   <td>resume()</td> 
   <td></td> 
   <td>恢复线程运行</td> 
  </tr> 
 </tbody> 
</table>

## 十、主线程与守护线程 ##

默认情况下，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 命令后，不会等待它们处理完当前请求

## 十一、五种状态 ##

这是从操作系统层面来描述的

![在这里插入图片描述][00905a331b8e46f7a46e468c1288f199.png]

*  【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
 *  【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
 *  【运行状态】指获取了 CPU 时间片运行中的状态
    
     *  当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
 *  【阻塞状态】
    
     *  如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
     *  等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
     *  与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
 *  【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

## 十二、六种状态 ##

这是从 Java API 层面来描述的  
根据 Thread.State 枚举，分为六种状态

![在这里插入图片描述][579aa5467be1434f9b788f547facaac4.png]

*  NEW 线程刚被创建，但是还没有调用 start() 方法
 *  RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
 *  BLOCKED ， WAITING ， TIMED\_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述
 *  TERMINATED 当线程代码运行结束

[49a9b92f74394dbdb2fc009a1f890a97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/a8d6521103c145dfa7c3feb5567556df.png
[53b3e2bc94c1453da736edbd06f74615.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/86522840ae9a4a56bb6a02566507dd64.png
[00905a331b8e46f7a46e468c1288f199.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7417f5e19d1a47f1861abd6bbea4047d.png
[579aa5467be1434f9b788f547facaac4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/55301c63623140bb94db2a1acb4e3fdb.png