多线程学习笔记（七）之wait与sleep的区别、线程停止及守护线程等

た入场券 2022-06-16 05:30 122阅读 0赞

# wait()方法与sleep()方法的区别 #

wait()方法与sleep()方法的区别：

1.  wait可以指定时间也可以不指定时间；sleep必须指定时间
2.  在同步中时，对cpu的执行权和锁的处理不同：  
    wait：释放cpu执行权，释放锁  
    sleep：释放cpu执行权，不释放锁

# 停止线程 #

## 定义循环结束标记 ##

因为线程运行代码一般都是循环，只要控制了循环即可。

例如通过flag的方式：

class StopThread implements Runnable{
        
        private boolean flag = true;
        public void run(){
            while (flag){
                System.out.println(Thread.currentThread().getName()+"......");
            }
        }
        public void setFlag(){
            flag = false;
        }
    }
    
    
    public class StopThreadDemo {
        
        public static void main(String[] args){
            StopThread st = new StopThread();
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(st);
            t1.start();
            t2.start();
            int num = 1;
            for (;;){
                if (++num==50){
                    st.setFlag();
                    break;
                }
                System.out.println("main..."+num);
            }
            System.out.println("over");
        }
    }

但是上述通过flag的方式有时候也不能使线程停止，例如我们修改下StopThread类的代码：

当线程Thread0获得执行权时，由于wait陷入等待状态，之后当Thread1获得执行权时，由于wait陷入等待状态，此时主线程执行结束，flag设置为false，但是却无法停止线程Thread0与Thread1，两者一直处于等待状态。**也就是说，如果线程处于冻结状态（sleep时间很长的时候也是同理），无法读取标记，那么如何使这种情况的线程结束？**下面的方式就可以解决这种问题。

## 使用interrupt（中断）方法 ##

该方法是结束线程的冻结状态，使线程回到运行状态中来。  
（注：stop方法已经过时不再使用）

public void interrupt()：中断线程

如果线程在调用Object类的wait(),wait(long)或wait(long,int)方法，或者该类的join(),join(long),join(long,int),sleep(long)或sleep(long，int)方法过程中受阻，则其中断状态将被清除（中断状态指程序冻结，即停止运行），它还将收到一个InterruptedException。即interrupt方法可以不等到sleep时间到即可以把其唤醒，是强制性的，因此是在程序应该等待的时候使其中断，会抛出InterruptedException异常。

因此对上述程序进行修改：

class StopThread implements Runnable{
        
        private boolean flag = true;
        public synchronized void run(){
            while (flag){
                try{
                    wait();
                }catch (InterruptedException e){
                    System.out.println(Thread.currentThread().getName()+"......"+e);
                    flag = false;
                }
                System.out.println(Thread.currentThread().getName()+"......");
            }
        }
        public void setFlag(){
            flag = false;
        }
    }
    
    
    public class StopThreadDemo {
        
        public static void main(String[] args){
            StopThread st = new StopThread();
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(st);
            t1.start();
            t2.start();
            int num = 1;
            for (;;){
                if (++num==50){
                    t1.interrupt();
                    t2.interrupt();
                    break;
                }
                System.out.println("main..."+num);
            }
            System.out.println("over");
        }
    }

运行结果：

![这里写图片描述][SouthEast]

t1.interrupt()与t2.interrupt()将线程从冻结状态中强制恢复到运行状态中来，让线程具备cpu的执行资格，但是会发生异常InterruptedException,因此原本处于try块中等待的线程t0与t1再interrupt方法之后抛出异常，进入catch块，通过在catch块中将flag置为false使其跳出while循环，最终达到停止线程的目的。

interrupt()只是改变中断状态而已  
　 interrupt()不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。  
　 如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。

wait() & interrupt()  
　 线程A调用了wait()进入了等待状态,也可以用interrupt()取消.  
　 不过这时候要小心锁定的问题.线程在进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时(**注意**是**等待的线程调用其自己的interrupt()**，例如上述demo中的t1与t2调用各自的interrupt方法),会先重新获取锁定,再抛出异常.在获取锁定之前,是无法抛出异常的.

# 守护线程 #

void setDaemon(boolean on):将该线程标记为守护线程（后台线程）或者用户线程。当正在运行的线程都是守护线程时，Java虚拟机退出。该方法必须在启动线程前调用。  
参数：on——如果为true，则将该线程标记为守护线程。

例如仍是上面的例子的main方法修改下：

public class StopThreadDemo {
        public static void main(String[] args){
            StopThread st = new StopThread();
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(st);
            t1.start();
            t2.setDaemon(true);
            t2.start();
            int num = 1;
            for (;;){
                if (++num==50){
                    t1.interrupt();
                    //t2.interrupt();
                    break;
                }
                System.out.println("main..."+num);
            }
            System.out.println("over");
        }
    }

虽然没有使用t2.interrupt()，但是由于将线程t2设置成为了守护线程，因此当最后由于等待wait只剩下t2线程时，其仍会停止，即只剩下守护线程时，其将停止，无论处于什么状态。

# join方法 #

public final void join() throws InterruptedException :等待该线程终止，\*\*抛出\*\*InterruptException-如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。  
（注：会抛出异常的时候，要么在所在函数的声明位置加上throws Exception，要么将其放入try\{\}catch\{\}块中）

class DemoTest implements Runnable{
        
        public void run(){
            for (int x=0;x<50;x++){
                System.out.println(Thread.currentThread().getName()+"......"+x);
    
            }
        }
    }
    
    public class JoinDemo {
        
        public static void main(String[] args) throws Exception{
            DemoTest d = new DemoTest();
            Thread t1 = new Thread(d);
            Thread t2 = new Thread(d);
            t1.start();
            //临时加入一个线程运算时可以使用join方法
            t1.join();//t1线程要申请加入进来运行，主线程等待t1终止之后再执行,即此时主线程处于冻结状态，是可以使用interrupt方法强制恢复回来的
            t2.start();
            t2.setPriority(Thread.MAX_PRIORITY);
            //t1.join();//t1线程要申请加入进来运行，主线程等待t1终止之后再执行，注意此时开启的线程是t1与t2，即t1与t2互相争夺执行权，但是主线程仅仅与t1线程相关联，在线程t1执行结束后主线程开始执行
            for (int x=0;x<50;x++){
                System.out.println(Thread.currentThread().getName()+"......"+x);
            }
        }

# 优先级 #

优先级越高代表被cpu执行的**概率**越大（1到10），一般1、5与10的差距是最大的。  
因为是静态常量，因此需要加上类名  
字段摘要:Thread.MAX\_PRIORITY，线程可以具有的最高优先级；Thread.MIN\_PRIORITY，线程可以具有的最低优先级；Thread.NORM\_PRIORITY，分配给线程的默认优先级，例如：

t2.setPriority(Thread.MAX_PRIORITY);

# Thread.yield()方法 #

yield():暂停当前正在执行的线程对象，并执行其他线程  
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。  
因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。例如：

class DemoTest implements Runnable{
        
        public void run(){
            for (int x=0;x<50;x++){
                System.out.println(Thread.currentThread().getName()+"......"+x);
                Thread.yield();
            }
        }
    }

[SouthEast]: /images/20220616/4354c55cfc96499eb302c5a79a480650.png