JUC并发编程——Java线程（一）

文章目录

1. 线程的创建
2. 线程运行
3. 主线程和守护线程
4. 线程状态
- 4.1 五种状态
- 4.2 六种状态

1. 线程的创建

1.1 方法1：直接使用Thread

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

1.2 方法2：使用Runnable配合Thread

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

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

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

java8以后可以使用lambda精简代码

Runnable r = () -> {
	log.debug("running");
};
Thread t = new Thread(r, "t2");
t.start();

小结：

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

1.3 方法3：FutureTask配合Thread

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

FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>(){
	@Override
	public Integer call() throws Exception {
		log.debug("running");
		Thread.sleep(1000);
		return 100;
	}
});

Thread t = new Thread(task);
t.start();

log.debug("{}", task.get());

2. 线程运行

2.1 原理

栈与栈帧
JVM由堆、栈、方法区所组成，其中栈内存给线程使用，每个线程启动后哦，虚拟机就会为其分配一块栈内存。

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

线程上下文切换（Thread Context Switch）
因为以下一些原因导致cpu不再执行当前的线程，转而执行另一个线程的代码

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

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

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

多线程

2.2 常见方法

2.2.1 start与run

启动线程必须要调用start()，不然对性能没影响。
start()不能多次调用

public class Test4{

	public static void main(String[] args){
		Thread t1 = new Thread("t1") {
			@Override
			public void run() {
				log.debug("running....");
			}
		};
		
		// t1.run();
		t1.start();
	}
}

2.2.2 sleep与yield

sleep

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

yield

调用yield会让当前线程从Running进入Runnable状态，然后调度执行其它同优先级的线程。如果这时没有同优先级的线程，那么不能保证让当前线程暂停的效果。
具体的实现依赖于操作系统的任务调度器。

线程优先级

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

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

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

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

2.2.3 join

等待线程运行结束

t1.start();
t1.join();

应用之同步（案例1）
以调用方角度来讲，如果

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

2.2.4 interrupt

打断sleep，wait，join的线程
eg：打断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());
}

eg：打断正常运行的线程，不会清空打断状态。

两阶段终止模式
在一个线程T1中如何“优雅”终止T2，即给T2一个善后的机会。

错误思路如下：

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

在这里插入图片描述

public class Test3{
	public static void main(String[] args){
		TwoPhaseTermination tpt = new TwoPhaseTermination();
		tpt.start();	
		
		Thread.sleep(3500);
		tpt.stop();
	}
}

class TwoPhaseTermination{
	private Thread monitor;

	// 启动监控线程
	public void start(){
		monitor = new Thread(() -> {
			while(true){
				Thread current = Thread.currentThread();
				if(current.isInterrupted()){
					log.debug("料理后事");
					break;
				}
				try{
					Thread.sleep(1000); // 情况1
					log.debug("执行监控记录"); // 情况2
				} catch(InterruptedExcetion e){
					e.printStackTrace();
					// 重新设置打断标记
					current.interrupt();
				}
			}
		}); 
	}

	// 停止监控线程
	public void stop(){
		monitor.intterupt();
	}
}

打断park线程，不会清空打断状态。
如果打断标记已经是true，则park会失效。

不推荐的方法：

stop() 停止线程运行
suspend() 挂起(暂停)线程运行
resume() 恢复线程运行

3. 主线程和守护线程

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

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
	log.debug("开始运行...");
	sleep(2);
	log.debug("运行结束...");
}, "daemon");
t1.setDaemon(true);
t1.start();

sleep(1);
log.debug("运行结束...");

4. 线程状态

4.1 五种状态

这是从操作系统层面来描述的
在这里插入图片描述

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

4.2 六种状态

这是从Java API层面来描述的。
在这里插入图片描述
根据Thread.State 枚举，分为六种状态。

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