java线程用法和区别
从操作系统的角度讲,os会维护一个ready queue(就绪的线程队列)。并且在某一时刻cpu只为ready queue中位于队列头部的线程服务。
但是当前正在被服务的线程可能觉得cpu的服务质量不够好,于是提前退出,这就是yield。
或者当前正在被服务的线程需要睡一会,醒来后继续被服务,这就是sleep。
sleep方法不推荐使用,可用wait。
线程退出最好自己实现,在运行状态中一直检验一个状态,如果这个状态为真,就一直运行,如果外界更改了这个状态变量,那么线程就停止运行。
sleep()使当前线程进入停滞状态,所以执行sleep()的线程在指定的时间内肯定不会执行;yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep()可使优先级低的线程得到执行的机会,当然也可以让同优先级和高优先级的线程有执行的机会;yield()只能使同优先级的线程有执行的机会。
当调用wait()后,线程会释放掉它所占有的“锁标志”,从而使线程所在对象中的其它synchronized数据可被别的线程使用。
waite()和notify()因为会对对象的“锁标志”进行操作,所以它们必须在 synchronized函数或synchronized block中进行调用。如果在non-synchronized函数或non- synchronized block中进行调用,虽然能编译通过,但在运行时会发生IllegalMonitorStateException的异常。
线程的状态
线程有四种状态,任何一个线程肯定处于这四种状态中的一种:
1) 产生(New):线程对象已经产生,但尚未被启动,所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。
2) 可执行(Runnable):每个支持多线程的系统都有一个排程器,排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时,表示它可能正处于线程池中等待排排程器启动它;也可能它已正在执行。如执行了一个线程对象的start()方法后,线程就处于可执行状态,但显而易见的是此时线程不一定正在执行中。
3) 死亡(Dead):当一个线程正常结束,它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。
4) 停滞(Blocked):当一个线程处于停滞状态时,系统排程器就会忽略它,不对它进行排程。当处于停滞状态的线程重新回到可执行状态时,它有可能重新执行。如通过对一个线程调用wait()函数后,线程就进入停滞状态,只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。
用法
sleep()
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
由于sleep()方法是Thread类的方法,因此它不能改变对象的机锁。所以当在一个Synchronized方法中调用sleep()时,线程虽然休眠了,但是对象的机锁没有被释放,其他线程仍然无法访问这个对象。sleep()方法不需要在同步的代码块中执行。但是sleep()可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException。
wait()和notify()和notifyAll()
wait()方法则会在线程休眠的同时释放掉机锁,其他线程可以访问该对象。wait()必须在同步的代码块中执行。当一个线程执行到wait()方法时,它就进入到一个和该对象相关的等待池中,同时失去了对象的机锁,可以允许其它的线程执行一些同步操作。但是wait()可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException。
wait可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊!
好,那怎么把对象锁收回来呢?
第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.
第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.
那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候,线程才会被唤醒"的意思了.
notify()唤醒在此对象监视器上等待的单个线程。当它被一个notify()方法唤醒时,等待池中的线程就被放到了锁池中。该线程将等待从锁池中获得机锁,然后回到wait()前的中断现场。
notifyAll()唤醒在此对象监视器上等待的所有线程。
suspend和resume()
join()
join()方法使当前线程停下来等待,直至另一个调用join方法的线程终止。值得注意的是,线程的在被激活后不一定马上就运行,而是进入到可运行线程的队列中。但是join()可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException。
yield()
Yield()方法是停止当前线程,让同等优先权的线程运行。如果没有同等优先权的线程,那么Yield()方法将不会起作用。
interrupt()
interrupt()中断线程。需要注意的是,InterruptedException是线程自己从内部抛出的,并不是interrupt()方法抛出的。对某一线程调用interrupt()时,如果该线程正在执行普通的代码,那么该线程根本就不会抛出InterruptedException。但是,一旦该线程进入到wait()/sleep()/join()后,就会立刻抛出InterruptedException。
这篇文章,给大家介绍一下 Thread 类的进阶知识,介绍并演示 interrupt()、join()、yield()的作用,还有守护线程的特点。
1 Thread 常用API
方法 | 描述 |
---|---|
void start() | 启动此线程,JVM将会执行这个线程的 run() 方法 |
void interrupt() | 将线程置为中断状态,中断标识设置为true。 |
boolean isInterrupted() | 判断此线程是否已处于中断状态,此方法不影响线程的中断状态。 |
static boolean interrupted() | 静态方法,判断此线程是否已处于中断状态,并清空此线程的中断状态,也就是说,如果此线程已经被中断了,调用此方法会返回true,并将此线程设置为非中断状态,中断标识设置为false。 |
void join() | 阻塞等待此线程死亡(运行结束), 举例:如果在主线程中执行了子线程(thread)thread.join(),那主线程会阻塞等待直到子线程thread死亡。 看不懂描述,可以下面的demo。 |
void join(long millis) | 最多阻塞等待多少毫秒等待此线程死亡(运行结束),0 表示永远等待直到此线程死亡 |
void sleep(long millis) | 使当前执行的线程在指定的毫秒数内休眠(暂时停止执行) |
void yield() | 让出cpu的执行权,将线程从运行转到就绪状态,但是下个时间片,该线程依然有可能被再次选中运行。 |
void setDaemon(boolean on) | 入参为true时,设置当前线程为守护线程,否则为用户线程,此方法在start()方法之前调用才有效。 守护线程:与父线程同时死亡(结束)。 用户线程:用户线程是独立存在的,不会因为其他用户线程退出而退出 |
boolean isDaemon() | 判断当前线程是否是守护线程 |
Thread中几个方法的作用
2 如何安全停止线程
2.1 线程自然死亡(结束)
- 自然执行完
- 抛出未处理异常
2.2 stop(),destroy(),resume(),suspend()已过时,不建议使用
- stop():强制结束线程,会导致线程不会正确释放资源,
- suspend():挂起,线程不会释放资源,容易导致死锁。
2.3 推荐使用 interrupt(),安全停止线程
注意:
java线程是 协作式,而非抢占式
合理方式: 应该调用一个线程的 interrupt()
方法中断一个线程,并不是强行关闭这个线程,只是跟这个线程打个招呼,将线程的中断标志位置为true,线程是否中断,由线程本身决定。
一般情况是:
我们在当前线程的run()方法中,判断当前线程的中断状态是否为true,进而决定是否退出当前线程的运行。
3 InterruptedException
Thread的sleep()
、join()
和Object的wait()
方法,都能够抛出InterruptedException
。interrupt()
方法只是将线程的中断标志位置为true,sleep()
、join()
、wait()
会不断检查线程的中断状态,如果当前线程中断标识位为ture,则会抛出InterruptEdException
。
注意:
线程抛出InterruptEdException
后,清空此线程的中断状态,也就是说,将此线程设置为非中断状态,中断标识设置为false。
抛出的InterruptEdException
被catch后,再调用isInterrupted()
,会返回false。
4 interrupt()、isInterrupted()、interrupted() 的使用
- interrupt():只是将线程的中断标志位置为true,并不是强行关闭这个线程,线程是否中断,由线程本身决定。
- isInterrupted():判断此线程是否已处于中断状态,此方法不影响线程的中断状态。
- interrupted():静态方法,获取当前线程的中断状态,不管当前线程中断状态如何,接着清空当前线程的中断状态。
4.1 演示 interrupt() 和 isInterrupted() 安全地退出线程运行
@Test
public void testInterrupt() throws InterruptedException {
// 演示 interrupt() 、 isInterrupted() 和 InterruptedException
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println("子线程开始执行任务..." + formatter.format(LocalDateTime.now()));
// 如果当前线程不处于中断状态,则每秒打印当前时间
while (!Thread.currentThread().isInterrupted()) {
try {
// sleep() 方法会检测线程的中断状态,如果已中断,则抛出InterruptedException
TimeUnit.SECONDS.sleep(1);
System.out.println("打印当前时间:" + formatter.format(LocalDateTime.now()));
} catch (InterruptedException e) {
System.out.println("catch InterruptedException:" + e.getMessage());
// InterruptedException 会清空中断状态,所以此时的中断状态为 false
System.out.println("当前线程中断状态:" + Thread.currentThread().isInterrupted());
// e.printStackTrace();
// InterruptedException 会清空中断状态,需要再次执行interrupt(),才能将线程状态置为已中断,退出循环
Thread.currentThread().interrupt();
}
}
System.out.println("子线程任务结束..." + formatter.format(LocalDateTime.now()));
}
});
thread.start();
TimeUnit.SECONDS.sleep(3);
System.out.println("主线程执行子线程的interrupt()");
// 只是将线程的中断标志位置为true,并不是强行关闭这个线程,线程是否中断,由线程本身决定。
thread.interrupt();
}
运行结果:
子线程开始执行任务...2020-09-17 18:18:44
打印当前时间:2020-09-17 18:18:45
打印当前时间:2020-09-17 18:18:46
主线程执行子线程的interrupt()
catch InterruptedException:sleep interrupted
当前线程中断状态:false
子线程任务结束...2020-09-17 18:18:47
4.2 演示 interrupted()
@Test
public void testInterrupted() throws InterruptedException {
// 演示 interrupted()
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
// 静态方法 Thread.interrupted() 获取当前线程的中断状态,不管当前线程中断状态如何,接着清空当前线程的中断状态
System.out.println("静态方法 Thread.interrupted() 获取当前线程的中断状态:" + Thread.interrupted() + ",然后清空中断状态");
System.out.println("成员方法 interrupted() 获取当前线程的中断状态:"+Thread.currentThread().interrupted());
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println("子线程开始执行任务..." + formatter.format(LocalDateTime.now()));
// 如果当前线程不处于中断状态,则每秒打印当前时间
if (!Thread.currentThread().isInterrupted()) {
System.out.println("打印当前时间:" + formatter.format(LocalDateTime.now()));
}
System.out.println("子线程任务结束..." + formatter.format(LocalDateTime.now()));
}
});
thread.start();
thread.interrupt();
TimeUnit.SECONDS.sleep(3);
}
运行结果:
静态方法 Thread.interrupted() 获取当前线程的中断状态:true,然后清空中断状态
成员方法 interrupted() 获取当前线程的中断状态:false
子线程开始执行任务...2020-09-17 18:20:13
打印当前时间:2020-09-17 18:20:13
子线程任务结束...2020-09-17 18:20:13
5 join()、join(long millis) 的使用
join():阻塞等待此线程死亡(运行结束)。
join(long millis):设置等待的超时时间,阻塞等待此线程死亡(运行结束),若超时时间为0,则一直等待直到此线程死亡。
应用场景:这个经常用在线程间的协作,一个线程等另一个线程运行结束后,再继续运行。
线程自然死亡(结束)
- 自然执行完
- 抛出未处理异常
看不懂就看看代码,应该容易理解一点:
5.1 join() demo 演示一个线程等另一个线程运行结束后再继续运行
public class TestJoin {
@Test
public void testJoin() throws InterruptedException {
// 演示 join() 方法使用
//线程自然死亡(结束):自然执行完或者抛出未处理异常
// main线程开始运行
System.out.println(Thread.currentThread().getName() + "开始运行...");
// t1 不需要等待其他线程运行结束
JoinThread t1 = new JoinThread("t1", null);
// t2 线程等待 t1 线程死亡,再继续往下运行
JoinThread t2 = new JoinThread("t2", t1);
// t3 线程等待 t2 线程死亡,再继续往下运行
JoinThread t3 = new JoinThread("t3", t2);
// t4 线程等待 t3 线程死亡,再继续往下运行
JoinThread t4 = new JoinThread("t4", t3);
t1.start();
t2.start();
t3.start();
t4.start();
// main线程等待 t4 线程死亡,再继续往下运行
t4.join();
System.out.println(Thread.currentThread().getName() + "继续运行");
System.out.println(Thread.currentThread().getName() + "运行结束...");
}
}
//自定义线程类
class JoinThread extends Thread {
// previousThread:前一个线程
// 当前线程等待 previousThread 运行结束再继续运行
private Thread previousThread;
public JoinThread(String name, Thread previousThread) {
super(name);
this.previousThread = previousThread;
}
@Override
public void run() {
if (this.previousThread != null) {
System.out.println(Thread.currentThread().getName() + "调用" + this.previousThread.getName() + ".join(),等待" + this.previousThread.getName() + "死亡");
try {
// 当前线程等待 previousThread 运行结束再继续运行
this.previousThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "继续运行");
}
try {
// sleep 2 秒,模拟业务执行花了2秒
TimeUnit.SECONDS