终止线程
Thread 提供了一个stop方法,已经废弃,强行把在执行的线程停止,可能导致数据不一致。
线程终止,我们自行决定线程何时退出:
class MyThread extends Thread{
volatile boolean stopme = false;
public void stopeMe(){
stopme = true;
}
@Override
public void run(){
while(true){
if(stopme){
System.out.println("exit by stop me");
break;
}
}
}
}
线程中断
线程中断有关三个方法:
public void Thread.interrupt() //中断线程
Public void boolean Thread.isInterrupted() //判断线程是否被中断
Public static boolean Thread.interrupted() //判断是否被中断,并请除当前中断状态
案例如下:
class MyThread extends Thread{
@Override
public void run(){
while(true){
System.out.println("Thread running");
if(Thread.currentThread().isInterrupted()){
System.out.println("interrput");
break;
}
}
}
}
public class fist{
public static void main(String args[]) throws InterruptedException{
Thread t1 = new MyThread();
t1.start();
Thread.sleep(2000);
t1.interrupt();
}
}
特别注意,如果在循环体中出现了wait() or sleep()这样操作的时候,中断可能被忽略。所以要再次设置中断标记位。
class MyThread extends Thread{
@Override
public void run(){
while(true){
System.out.println("Thread running");
if(Thread.currentThread().isInterrupted()){
System.out.println("interrput");
break;
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("when sleep interrupt");
Thread.currentThread().interrupt();
}
System.out.println("Thread end");
}
}
}
public class fist{
public static void main(String args[]) throws InterruptedException{
Thread t1 = new MyThread();
t1.start();
Thread.sleep(1000);
t1.interrupt();
}
}
Thread.sleep()方法会让当前线程休眠若干时间,休眠时,如果中断线程,会抛出一个InterruptException中断异常,此时它会清除中断标志位,如果在catch住异常后,不加处理,在下次循环开始前,就无法捕获这个中断,所以要在异常助理中,再次设置中断标记位。
线程等待(wait)和通知(notify)
为了支持线程之间的协作,JDK提供了两个非常重要的接口,线程等待wait()方法和线程通知方法notify().这两个方法不是在Thread类中的,而是在Object类中的,这意味着任何对象都能调用这两种方法
public final void wait() throws InterruptException
public final native void notify()
如果一个线程调用了object.wait()方法,那么他就会进入object对象的等待队列。这个队列中可能会有多个等待线程,因为系统运行同时等待某个对象。当object.notify()被调用时,他就会从这个等待对系列中随机选择一个线程唤醒。这个唤醒是不公平的,不是先等待的线程会优先选择。
object.notifyAll()方法,他会唤醒等待队列中的所有线程。
这两个方法不是可以随便调用的,他必须包含在对应的synchronized语句中,无论是wait还是notify都需要首先获得目标对象的一个监视器。
import java.util.Objects;
public class fist{
final static Object object = new Object();
public static class MyThread_1 extends Thread{
@Override
public void run(){
synchronized (object) {
System.out.println(System.currentTimeMillis()+"T1 start");
try {
System.out.println(System.currentTimeMillis()+"T1 wait");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(System.currentTimeMillis()+"T1 end");
}
}
}
public static class MyThread_2 extends Thread{
@Override
public void run(){
synchronized (object) {
System.out.println(System.currentTimeMillis()+"T2 start and notify");
object.notify();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String args[]){
Thread t1 = new MyThread_1();
Thread t2 = new MyThread_2();
t1.start();
t2.start();
}
}
开启了t1 ,t2 两个线程,t1执行了object.wait()方法。注意,在wait方法执行前,t1申请了object对象锁。因此在执行object.wait()时,持有的wait()方法执行后,t1会进行等待,并且释放object对象的锁,t2在执行notify之前也会得到object对象锁,在notify执行后释放object对象的锁。
执行效果如下:
T1 start
T1 wait
T2 start and notify
T1 end
挂起(suspend)和继续执行(resume)
两个方法都已经废弃
不推荐使用suspend()去挂起线程的原因,是因为suspend()在导致线程暂停的同时,并不会去释放任何资源锁
等待线程结束(join)和谦让(yield)
一个线程的输入可能会非常依赖另一个线程的输出,此时,这个线程就需要等待依赖线程的执行完毕,才能继续执行。
public final void join() throws InterruptedException
public final synchronized void join() throws InterruptedException
第一个join方法标识无限等待,他会一直阻塞线程,知道目标线程执行完毕,
第二个给出了一个最大等待时间,如果时间超过给定时间目标线程还在执行,当前线程会不等待,直接执行。
import java.util.Objects;
public class fist{
public volatile static int i = 0;
public static class MyThread extends Thread{
@Override
public void run(){
for(i=0;i<10000000;i++);
}
}
public static void main(String args[]) throws InterruptedException{
Thread t = new MyThread();
t.start();
t.join();
System.out.println(i);
}
}
如果不适用join等待myThrea线程,那么得到的可能是0或者是一个很小的数值,因为myThread线程还没有执行,i的值就被打印出来了。但在使用join方法后,标识主线程原意等待MyThread线程执行完毕,在join返回时,MyThread已经执行完毕,i为10000000
Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
结论:yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。
其他线程相关操作
获取当前线程
Thread.currentThread()//获取当前线程
Thread.currentThread.isInterrupted() //获取当前线程并中断线程