并发线程使用介绍（一）

2.1 线程的状态

网上对线程状态的描述很多，有5种，6种，7种，都可以接受
5中状态一般是针对传统的线程状态来说（操作系统层面）
[image]
Java中给线程准备的6种状态
[image]
NEW：Thread对象被创建出来了，但是还没有执行start方法。
RUNNABLE：Thread对象调用了start方法，就为RUNNABLE状态（CPU调度/没有调度）
BLOCKED、WAITING、TIME_WAITING：都可以理解为是阻塞、等待状态，因为处在这三种状态下，CPU不会调度当前线程
BLOCKED：synchronized没有拿到同步锁，被阻塞的情况
WAITING：调用wait方法就会处于WAITING状态，需要被手动唤醒
TIME_WAITING：调用sleep方法或者join方法，会被自动唤醒，无需手动唤醒
TERMINATED：run方法执行完毕，线程生命周期到头了
在Java代码中验证一下效果
NEW：

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
 });
System.out.println(t1.getState());
}

RUNNABLE：

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while(true){
}
});
t1.start();
Thread.sleep(500);
System.out.println(t1.getState());
}

BLOCKED：

public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Thread t1 = new Thread(() -> {
// t1线程拿不到锁资源，导致变为BLOCKED状态
synchronized (obj){
}
 });
// main线程拿到obj的锁资源
synchronized (obj) {
t1.start();
Thread.sleep(500);
System.out.println(t1.getState());
}
}

WAITING：

public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Thread t1 = new Thread(() -> {
synchronized (obj){
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
Thread.sleep(500);
System.out.println(t1.getState());
}

TIMED_WAITING：

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
Thread.sleep(500);
System.out.println(t1.getState());
}

TERMINATED：

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
Thread.sleep(1000);
 System.out.println(t1.getState());
}

2.2 线程的常用方法

2.2.1 获取当前线程

Thread的静态方法获取当前线程对象

public static void main(String[] args) throws ExecutionException, InterruptedException {
// 获取当前线程的方法
Thread main = Thread.currentThread();
System.out.println(main);
// "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";
// Thread[main,5,main]
}

2.2.2 线程的名字

在构建Thread对象完毕后，一定要设置一个有意义的名称，方面后期排查错误

public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName());
});
t1.setName("模块-功能-计数器");
 t1.start();
}

2.2.3 线程的优先级

其实就是CPU调度线程的优先级、
java中给线程设置的优先级别有10个级别，从1~10任取一个整数。
如果超出这个范围，会排除参数异常的错误

public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("t1:" + i);
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("t2:" + i);
}
});
t1.setPriority(1);
t2.setPriority(10);
t2.start();
t1.start();
}

2.2.4 线程的让步

可以通过Thread的静态方法yield，让当前线程从运行状态转变为就绪状态。

public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
if(i == 50){
Thread.yield();
}
System.out.println("t1:" + i);
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("t2:" + i);
}
});
t2.start();
t1.start();
}

2.2.5 线程的休眠

Thread的静态方法，让线程从运行状态转变为等待状态
sleep有两个方法重载：
● 第一个就是native修饰的，让线程转为等待状态的效果
● 第二个是可以传入毫秒和一个纳秒的方法（如果纳秒值大于等于0.5毫秒，就给休眠的毫秒值+1。如果传入的毫秒值是0，
纳秒值不为0，就休眠1毫秒）
sleep会抛出一个InterruptedException

public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis());
Thread.sleep(1000);
System.out.println(System.currentTimeMillis());
}