java线程
大家好，我是傻明蚕豆，今天为大家带来java线程的基础知识。
我在CSDN也发布了，编辑比这里美观：https://blog.csdn.net/weixin_44668634/article/details/109147514
一、线程的概念；
进程：进程就是一个在内存中运行的应用程序，比如你电脑在运行的一个QQ，如果你再打开个哭狗，那就是另一个进程，每个进程都有自己的独立内存空间，一个进程中可以有多个线程。
线程：线程是进程里面的一个执行流程，是CPU调度和分派的基本单位，一个进程中可以有多个线程，线程与进程内的其他线程一起共享所有该进程的资源，每个线程有自己的堆栈和局部变量。java程序中最少有两个线程，一个main线程，一个是垃圾回收线程。
二、线程的生命周期；
NEW状态：
一个已创建而未启动（还没调用Thread.start()方法）的Java线程，就是处于NEW状态。
RUNNABLE状态：
当线程调用了start()之后，就会进入RUNNABLE状态，RUNNABLE状态包含两个子状态：READY和RUNNING。
READY：准备状态，当被线程调度器进行调度，会变为RUNNING状态。
RUNNING：运行状态，线程正在运行，run()方法中的代码在执行。
当Java线程调用yield()方法时或者由于线程调度器的调度，线程的状态有可能由RUNNING转变为READY，Thread.getState()可以获取到状态。
WAITING状态：
无限期等待状态，需要唤醒，进入该状态是由于调用了下面方法之一：不带超时的Object.wait(),不带超时的Thread.join(),LockSupport.park() 。
TIMED WAITING状态：
时间等待状态,无需唤醒，进入该状态是由于调用了下面方法之一：Thread.sleep(time),Object.wait(time),Thread.join(time),LockSupport.parkNanos(time),LockSupport.parkUntil(time)
BLOCKED状态：
阻塞状态，遇到阻塞的I0操作或者在等待某个锁资源都会进入阻塞状态。
TERMINATED状态：
死亡状态，线程的最终状态，在该状态的线程不会再切换到其它任何状态，意味着线程的整个生命周期都结束了。
三、线程的创建方式；
1、继承Thread类
public class Thread1 extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
Thread t=new Thread1();
t.start();
//t.start();
}
}
2、实现Runnable接口
public class Thread2 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
new Thread(new Thread2()).start();
}
}
3、实现Callable接口
public class Thread3 implements Callable{
public static void main(String[] args) {
ExecutorService executorService=Executors.newFixedThreadPool(1);
Thread3 t=new Thread3();
Future future=executorService.submit(t);
System.out.println("result:"+future);
}
@Override
public Object call() throws Exception {
String threadName=Thread.currentThread().getName();
System.out.println("name:"+threadName);
return threadName;
}
}
四、线程的启动和停止；
怎么启动线程？
Thread类实现了Runnable接口，所以创建线程继承Thread类或者实现Runnable接口都是一样的，因为java是单继承，所以如果要继承其他类，那就只有实现Runnable接口了。
线程启动必须调用Thread.start方法，run()方法只是一个类中的普通方法，调用run方法跟调用其他普通方法一样，而start()是会创建新线程，然后新线程调用run方法。
我们来看看Thread类的源码（JDK1.8）：
private volatile int threadStatus = 0;
public synchronized void start() {
if (threadStatus != 0)｛
throw new IllegalThreadStateException();
｝
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then it will be passed up the call stack */
}
}
｝
private native void start0();
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
threadStatus和枚举类State就是用来记录Thread的状态，Thread类中并没有对threadStatus进行过赋值，那么threadStatus应该是在start0方法里面改变了。
start0方法是native修饰的，所以是调用了C++实现的方法，而threadStatus是volatile修饰，保证可见性，
因此native方法进行变量threadStatus修改的同时Thread类中就能同时获取到该变量的最新值。
同时start方法是synchronized修饰的，所以即使多线程同时调用start方法，也能保证原子性。
线程初始化后状态为0，所以start方法只可以调用一次，因为线程调用过一次start方法后，状态就会改变，那么threadStatus就不等于0了，
由于threadStatus是在c++里面修改，所以看不到ThreadStatus等于多少，但肯定不等于0，所以再调用start方法就会抛出IllegalThreadStateException。
如何中断线程？
不要问我为什么不用stop方法。
在Thread线程类里面有个isInterrupted方法，
private native boolean isInterrupted(boolean ClearInterrupted);
是一个native方法，Thread类有两个public方法调用了该native方法，
public boolean isInterrupted() {
return isInterrupted(false);
}
这个方法只返回线程的中断状态，并没有去改变线程的中断状态。
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
这个方法是个静态方法，所以只作用于当前正在执行的线程，方法里面调用了currentThread()获取当前线程，该方法返回当前线程的中断状态，并且会重置线程的中断状态。
这两个方法都只是查看线程的中断状态，并没有中断线程，还有一个方法interrupt()：
public void interrupt() {
if (this != Thread.currentThread())
checkAccess();
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // Just to set the interrupt flag
b.interrupt(this);
return;
}
}
interrupt0();
}
这个就是中断线程的方法，首先判断是否是当前线程，如果不是调用checkAccess()方法，大概就是查询权限吧，也就是说一个线程只允许自己中断。
我们再看看这个方法的注释，调用interrupt方法时，如果线程因为以下方法的调用而处于阻塞中，线程的中断标志会被清除，并抛出一个InterruptedException。
以下方法包括：Object类的wait()、wait(long)、wait(long, int)和Thread类的join()、join(long)、join(long, int)、sleep(long)、sleep(long, int)。
如果线程没有因为以上方法调用而进入阻塞状态的话，那么中断这个线程仅仅会设置它的中断标志位，而不会抛出InterruptedException。
总结：调用interrupt方法，并不会中断一个正在运行的线程，而是将线程的中断标志设为true，在某些情况下抛出一个InterruptedException罢了。
也就是说，无论是设置中断状态，还是抛出InterruptedException，那都是给当前线程的建议，至于在收到这些中断的建议后，当前线程要怎么处理，完全取决于当前线程。
那么到底怎么中断线程呢？
设置中断标记法
public static void test1(){
Thread thread=new Thread(()->{
System.out.println("线程启动了");
while(!Thread.currentThread().isInterrupted()){ //默认情况下isInterrupted() 返回 false
System.out.println(Thread.currentThread().isInterrupted());
}
System.out.println("线程结束了");
},"test1");
thread.start();
try {
Thread.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//通过调用interrupt()，把while里面的isInterrupted()返回变为true
thread.interrupt();
}
当main线程运行到最后一行代码thread.interrupt();，那么Thread.currentThread().isInterrupted()就等于true，
然后循环不成立，接着执行输出"线程结束了"，那岂不是没法中断？所以逻辑代码都写在循环里面才能使用中断标记法。
捕获InterruptedException法
public static void test2(){
Thread thread=new Thread(()->{
System.out.println("线程启动了");
while(!Thread.currentThread().isInterrupted()){
try {
Thread.sleep(1100);
System.out.println(Thread.currentThread().isInterrupted());//逻辑处理代码
} catch (InterruptedException e) {
System.out.println("出异常了");
//Thread.currentThread().interrupt();//调用中断方法
//break;//跳出循环
//return ;//跳出方法，不再执行输出"线程结束了"的逻辑
}
}
System.out.println("线程结束了");
},"test2");
thread.start();
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//线程执行了一段时间（上面睡眠5秒），我突然想要线程停止，于是调用interrupt方法
thread.interrupt();
}
这里如果线程test2正在sleep，main线程这时候执行thread.interrupt()，那么会抛出异常，并且线程的中断标志会被清除，所以要做什么操作，就必须在catch里面搞了。
或者这样写：
public static void test3(){
Thread thread=new Thread(()->{
System.out.println("线程启动了");
try {
while(!Thread.currentThread().isInterrupted()){
Thread.sleep(1100);
System.out.println(Thread.currentThread().isInterrupted());//逻辑处理代码
}
} catch (InterruptedException e) {
System.out.println("出异常了");
//return ;//跳出方法，不再执行输出"线程结束了"的逻辑
}
System.out.println("线程结束了");
},"test3");
thread.start();
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt();
}
五、线程的其他方法；
sleep方法：
public static native void sleep(long millis) throws InterruptedException;
sleep是一个静态的native方法，它作用于当前线程，当调用sleep方法后，当前线程会让出CPU资源，但不会释放锁。
Thread.sleep() 与 Thread.currentThread().sleep() 是一样的，只不过一个是用类直接调用静态方法, 一个是用类的实例调用静态方法。
yield方法：
public static native void yield();
yield是一个静态的native方法，当调用yield方法后，当前线程表示会让出CPU，但到底让不让是随机的，或者是CPU决定的。
join方法：
调用join方法后，会让当前线程先执行，如果指定时间，则先执行指定时间，如果时间为0，则是让当前线程执行完为止。
比如有线程T1和线程T2，线程T1里面有这样代码：T2.jion(0);
那么T1会立刻停止让线程T2执行，一直到T2执行完，T1才会继续执行，即使T2里面调用了sleep方法让出CPU资源，T1也会等T2执行完才能获得CPU资源。
我们来看一下源码：
public final synchronized void join(long millis) throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
//当参数为0，while循环会一直检查T2是否存活，存活的话T1就一直wait(0)。
//注意：如果T1在执行T2.jion(0)时，T2还没start，那么T2就不存活，那么T2.jion(0)相当于白写了。
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
好了，java线程就介绍到这里，如有问题请留言一起探讨。
谢谢观看！
