Java线程学习笔记

1、判断线程存活

1. 当线程run()或者call()方法执行结束，线程进入终止状态

2. 当线程内发生异常，并且异常没有被捕获，线程进入终止状态

3. 线程调用stop()方法后，线程进入终止状态(不推荐使用)

当主线程结束时，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来后，它就拥有和主线程相同的地位，它不会受主线程的影响。

为了测试某个线程是否已经死亡，可以调用线程对象的isAlive()方法，当线程处于就绪、运行、阻塞3种状态时，该方法将返回true；当线程处于新建、死亡2种状态时，该方法将返回false。

/**

* isAlive()方法练习

public class IsAliveDemo1 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

for (int i = 0; i < 50; i++) {

System.out.println(i);

}

});

System.out.println("线程的状态:"+t.getState());//NEW

System.out.println("线程启动前:"+t.isAlive());//false

System.out.println("----------------------");

t.start();

System.out.println("线程的状态:"+t.getState());//RUNNABLE

System.out.println("线程启动后："+t.isAlive());//true

System.out.println("----------------------");

TimeUnit.SECONDS.sleep(5);

System.out.println("线程的状态:"+t.getState());//TERMINATED

System.out.println("线程结束后："+t.isAlive());//false

}

/**

*isAlive()方法练习2

public class IsAliveDemo2 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

for (int i = 0; i < 40; i++) {

System.out.println(i);

if(i==15){

synchronized (IsAliveDemo2.class){

try {

IsAliveDemo2.class.wait();

} catch (InterruptedException e) {

throw new RuntimeException(e);

}

});

//启动前获取状态

System.out.println("线程启动前："+t.isAlive());

t.start();

System.out.println("线程启动后："+t.isAlive());

//主线程休眠2秒，给予t线程充足的执行时间

TimeUnit.SECONDS.sleep(2);

System.out.println("线程抛出异常后："+t.isAlive());

}

注意：不要对处于死亡状态的线程调用start()方法，程序只能对新建状态的线程调用start()方法，对新建状态的线程两次调用start()方法也是错误的。这都会引发IllegalThreadState Exception异常。

/**

* 练习3

public class IsAliveDemo3 {

public static void main(String[] args) throws InterruptedException {

Thread t = new Thread(()->{

for (int i = 0; i < 10; i++) {

System.out.println(i);

}

});

t.start();

//t.start(); 抛出IllegalThreadStateException异常

TimeUnit.SECONDS.sleep(2);

System.out.println(t.getState());//TERMINATED

//t.start(); 抛出IllegalThreadStateException异常

}

2、线程控制

（1）Join()

join()方法相当于插入，例如在T2线程中调用了线程T1.join()方法，则T2线程会一直等待T1线程执行结束后再继续执行。

就是在A线程中调用线程B的join()方法，线程A会一直等待直到线程B执行结束再执行，也可以理解为插队。

注意：当T2线程执行过程中被T1线程Join，线程T1执行时，T2处于WAITING

/**

* Join()方法

public class JoinDemo1 {

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{

for (int i = 0; i < 30; i++) {

System.out.println(Thread.currentThread().getName()+"--------->"+i);

}

},"t1");

Thread t2 = new Thread(()->{

for (int i = 0; i < 30; i++) {

System.out.println(Thread.currentThread().getName()+"#########"+i);

if (i == 10){

try {

//t1线程调用t2线程的join()方法，插队执行

t1.join();

} catch (InterruptedException e) {

throw new RuntimeException(e);

}

},"t2");

t1.start();

System.out.println(t1.getState());

t2.start();

//main t1 t2 三个线程交替执行

for (int i = 0; i < 60; i++) {

System.out.println(Thread.currentThread().getName()+"***********"+i);

}

（2）Join(long millis)

如果T2线程执行过程中调用为了T1线程的join(long millis)方法，T2线程最多等待T1线程millis毫秒，到达时间后，如果T1线程没有结束，则和T2线程交替执行。

注意：T2线程被T1线程join(millis)后，T2线程在等待T1线程执行的过程中处于TIMED_WAITING状态

/**

* Join()方法

public class JoinDemo2 {

public static void main(String[] args) throws InterruptedException {

Thread t1 = new Thread(()->{

for (int i = 0; i < 50; i++) {

System.out.println(Thread.currentThread().getName()+"-------->"+i);

try {

TimeUnit.SECONDS.sleep(1);

} catch (InterruptedException e) {

throw new RuntimeException(e);

}

},"t1");

Thread t2 = new Thread(()->{

for (int i = 0; i < 200; i++) {

System.out.println(Thread.currentThread().getName()+"##########"+i);

if (i == 20){

//启动t1线程

t1.start();

try {

//在线程t2中插入

t1.join(3000);

} catch (InterruptedException e) {

throw new RuntimeException(e);

}

},"t2");

//启动进程

t2.start();

System.out.println("--------------------");

//主线程休眠让t2线程执行

TimeUnit.SECONDS.sleep(2);

//t2线程的状态

System.out.println(t2.getState());//TIMED_WAITING

}

（3）守护线程

在后台运行的，并为其他的线程提供服务的线程被称为“后台线程”，又称为“守护线程”，JVM的垃圾回收线程就是典型的后台线程。

特征：如果所有的前台线程都死亡，后台线程会自动死亡。

守护线程必须在启动前将其守护状态设置为true，启动之后不能再将用户线程设置为守护线程，否则JVM会抛出一个InterruptedException异常。具体来说，如果线程为守护线程，就必须在线程实例的start()方法调用之前调用线程实例的setDaemon(true)，设置其daemon实例属性值为true。

守护线程存在被JVM强行终止的风险，所以在守护线程中尽量不去访问系统资源，如数据库连接。守护线程被强行终止时，可能会引发系统资源操作不负责任的中断，从而导致资源不可逆的损坏。

守护线程创建的线程也是守护线程。在守护线程中创建的线程，新的线程都是守护线程。在创建之后，如果通过调用setDaemon(false)将新的线程显式地设置为用户线程，新的线程可以调整成用户线程。

/**

* setDaemon()方法

public class DaemonDemo {

public static void main(String[] args) {

Thread t1 = new Thread(()->{

for (int i = 0; i < 100; i++) {

System.out.println(Thread.currentThread().getName()+"===="+i);

}

},"t1");

//设置线程为守护线程必须在启动前设置