精华内容
下载资源
问答
  • package 线程生命周期; public class TestSleep { public static void main(String[] args) { // TODO Auto-generated method stub MyThread mythread = new MyThread(); mythread.start();//子线程,每隔...

    Sleep


    package 线程生命周期;
    
    public class TestSleep {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		MyThread mythread = new MyThread();
    		mythread.start();//子线程,每隔50毫秒输出一行字
    		try {
    			MyThread.sleep(2000);//这个是暂定的是主线程的
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		for (int i = 1; i < 20; i++) {
    			System.out.println("main:"+i);
    		}
    		
    	}
    
    }
    
    //输出1-100的数
    class MyThread extends Thread{
    	
    	public void run(){
    		for (int i = 1; i <= 100; i++) {
    			System.out.println(i);
    			try {
    				Thread.sleep(50);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    	
    }


    Join

    package 线程生命周期;
    
    public class TestJoin {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Mythread3 th1 = new Mythread3();
    		th1.setI(20);
    		Mythread3 th2 = new Mythread3();
    		th2.setI(100);
    		/*//交替输出
    		th1.start();
    		th2.start();*/
    		//先执行th1
    		th1.start();
    		try {
    			th1.join();
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		th2.start();
    		
    	}
    
    }
    
    class Mythread3 extends Thread{
    
    	private int i;
    	
    	
    	public int getI() {
    		return i;
    	}
    
    	public void setI(int i) {
    		this.i = i;
    	}
    
    
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		super.run();
    		
    		for (int j = i; j < i + 50; j++) {
    			System.out.println(j);
    			try {
    				Thread.sleep(10);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		
    	}
    }
    


    Yeile 

    package 线程生命周期;
    
    public class TestYeile {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//创建三个优先级不一样的线程 10 5 1的时候都是高的在执行所以全部选5
    		new MyThread2("低级",5).start();
    		new MyThread2("高级",5).start();
    		new MyThread2("中级",5).start();
    		
    	}
    
    }
    
    //结合线程信息输出1-10
    class MyThread2 extends Thread{
    
    	public MyThread2() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    	//创建一个构造方法用于给线程命名以及优先级
    	public MyThread2(String name,int pro){
    		super(name);
    		setPriority(pro);
    	}
    	
    	public void run(){
    		for (int i = 1; i <= 20; i++) {
    			System.out.println(getName()+"线程第"+i+"次运行");
    			if(i == 5)
    				Thread.yield();//线程让步
    		}
    	}
    }


     Interrupt线程中断

    package 线程生命周期;
    
    import java.util.Scanner;
    
    public class TestInterrupt {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		MyThread4 th4 = new MyThread4();
    		th4.start();
    		try {
    			Thread.sleep(3000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		System.out.println("是否中断打印");
    		boolean flag  = true;
    		if(flag)
    			th4.interrupt();
    	}
    
    }
    
    
    //无限次打印i
    class MyThread4 extends Thread{
    	int i = 0;
    	
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		super.run();
    		while(true){
    			System.out.println(i);
    			try {
    				Thread.sleep(500);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				System.out.println("程序执行被中断了");
    				return;
    				//e.printStackTrace();
    			}
    			i++;
    		}
    	}
    }
    


    Deamon后台线程

    package 线程生命周期;
    
    public class TestDeamon {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		MyThread5 th5 = new MyThread5();
    		
    		MyDeamon myd = new MyDeamon();
    		myd.setDaemon(true);
    		myd.start();
    		th5.start();
    		
    	}
    
    }
    
    class MyThread5 extends Thread{
    
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		super.run();
    		for (int i = 1; i <= 5; i++) {
    			
    			System.out.println("前台线程第"+i+"次执行");
    			try {
    				Thread.sleep(200);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    class MyDeamon extends Thread{
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		super.run();
    		for (int i = 1; i <= 5; i++) {
    			System.out.println("后台线程第"+i+"次执行");
    			try {
    				Thread.sleep(10);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    


    展开全文
  • interrupt() 中断线程, ... * 除非当前线程中断自身, * 否则在checkAccess中将会抛出SecurityException * * 如果当前线程在 wait、join、sleep 中被阻塞, * 将会清除它的中断状态(isInterrup...

    interrupt()

    中断线程,
    具体使用场景可以查看下面的源码以及注释

        /**
         * 中断线程
         *
         * 除非当前线程中断自身,
         * 否则在checkAccess中将会抛出SecurityException
         *
         * 如果当前线程在 wait、join、sleep 中被阻塞,
         * 将会清除它的中断状态(isInterrupted() is false),
         * 并抛出InterruptedException
         *
         * 如果当前线程在java.nio.channels上的I/O操作被阻塞,
         * 则通道将被关闭,线程的中断状态被设置(isInterrupted() is true),
         * 并抛出ClosedByInterruptException
         *
         * 如果当前线程在java.nio.channels.Selector中被阻塞,
         * 则线程的中断状态被设置(isInterrupted() is true),
         * 并立即返回,可能带有非零值。
         * 类似于调用了java.nio.channels.Selector的wakeup方法
         *
         * 如果上面的条件都不存在,
         * 则线程的中断状态被设置(isInterrupted() is true)
         *
         */
        public void interrupt() {
            if (this != Thread.currentThread())
                checkAccess();
    
            synchronized (blockerLock) {
                Interruptible b = blocker;
                if (b != null) {
                    interrupt0();           // Just to set the interrupt flag
                    b.interrupt(this);
                    return;
                }
            }
            interrupt0();
        }
    

    isInterrupted()

        /**
         * 测试这个线程是否被中断,
         * 但是线程的中断状态,不受此方法的影响
         *
         * 当一个线程死亡的时候,
         * 设置线程的中断状态将会被忽略,
         * 调用此方法将返回false
         *
         * 如果这个线程被中断(即:中断状态被设置)
         * 则返回true,否则,返回false。
         */
        public boolean isInterrupted() {
            return isInterrupted(false);
        }
    

    interrupted()

        /**
         * 测试当前线程是否中断
         * 返回结果与isInterrupted返回值一样,
         * 
         * 但该方法会清除线程的中断状态
         * 
         * 即:不过当前线程状态如何,如果连续调用两次此方法,
         * 则,第二次调用将返回false。
         * 因为,第一次调用时已清除了中断状态。
         */
        public static boolean interrupted() {
            return currentThread().isInterrupted(true);
        }
    

    code of demo:

    package cn.qbz.thread;
    
    import org.springframework.validation.annotation.Validated;
    
    /**
     * @Author: 花生米
     * @Date: 2018/11/16 10:20
     */
    public class InterruptTest {
    
        public static void main(String[] args) throws InterruptedException {
            Test2 test2 = new Test2();
            System.out.println("\n线程未启动之前:" + test2.isInterrupted());
            test2.start();
            System.out.println("\n调用interrupt前:" + test2.isInterrupted());
    
            test2.interrupt();
            System.out.println("\n调用interrupt,中断状态被设置:" + test2.isInterrupted());
    
            while (true) {
                if (test2.isAlive()) {
                    Thread.sleep(2000);
                } else {
                    break;
                }
            }
            System.out.println("\n线程已死亡:" + test2.isInterrupted());
        }
    
    }
    
    class Test2 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 600001; i++) {
                System.out.print("");
    
                if (i == 600000) {
                    System.out.println("interrupted:" + Thread.interrupted());
                    System.out.println("interrupted late::" + isInterrupted());
                }
            }
            System.out.println("线程即将死亡...");
            
            interrupt();
            System.out.println("interrupted late::" + isInterrupted());
        }
    
    }
    
    


    注意事项:

    interrupted 测试的时当前线程;
    isInterrupted 测试的时被调用的线程。

    展开全文
  • 线程中断有关的3个方法: interrupt():中断线程,改变其线程的中断标志位(仅仅只有一个通知的作用),但是否中断由自己线程判断决定。false——&gt;true isInterrupted():返回线程目前的中断标志位值 ...

    线程中的中断标志位

    一.与线程中断有关的3个方法:

    interrupt():中断线程,改变其线程的中断标志位(仅仅只有一个通知的作用),但是否中断由自己线程判断决定。false——>true

    isInterrupted():返回线程目前的中断标志位值

    Thread.interrupted():返回线程目标的中断标志位,并将标志位复位 true——>false

    Thread.interrupted()源码:

    ClearInterrupted参数:true-中断标志位复位   false-不复位

    二.线程中使用sleep,wait,join等方式会使线程阻塞,interrupt阻塞中的线程会抛出interruptedException异常,并将中断标志位复位

    (true——>false)。

    安全的中断线程:自定义标志+中断标志位监测

    private static class TestThread  extends  Thread {
    		private volatile boolean on =true;
    		private long i = 0;
    		
    		
    		@Override
    		public void run() {
    			// TODO Auto-generated method stub
    			while(on &&  !Thread.currentThread().isInterrupted()){//未中断
    				try {
    					System.out.println("i="+i++);
    					//wait,sleep,join等阻塞
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {//T——>F
    					// TODO Auto-generated catch block
    					//e.printStackTrace();
    					System.out.println("线程:"+Thread.currentThread().getName()+",异常中重新置位中断标志");
    					Thread.currentThread().interrupt();//F——>T
    					System.out.println("1-1:"+Thread.currentThread().isInterrupted());
    				}
    			}
    			System.out.println("1-2:on:"+on+"|中断标志位:"+Thread.currentThread().isInterrupted()+"|线程名称:"+Thread.currentThread().getName());
    			System.out.println("阻塞解除!");
    		}
    		
    		public void cancel(){
    			on=false;
    			interrupt();//F ——>T
    			System.out.println("解除cancel中,thread.getName():"+getName());//运行的线程
    			//Thread.currentThread().interrupt();//中断的是主线程(即调用cancel方法的线程本身)
    			System.out.println("解除cancel中,Thread.currentThread:"+Thread.currentThread().getName());//调用cancel的线程(在此是main)
    		}
    	}

    测试main类:

    public static void main(String[] args)  {
    		TestThread th=new TestThread(); 
    		th.start();
    		Thread.sleep(5000);
    		th.cancel();
    	}

    疑问1:为什么要自定义标志+中断标志去判断

    如果只使用flag是不安全的取消操作,阻塞后,线程不会时刻去判断while中的条件,需要等待被唤醒(而interrupt后线程会立即响应)才会去检查条件是否满足。
    中断的操作首先改变flag,再使用interrupt() 
    1.如果只使用flag去判断,出现interrupt()异常,未成功把中断标志置为true,也不能代表中断已经成功。
    2.如果只使用!Thread.currentThread().isInterrupted(),假如在程序运行过程中,中断标志位因为异常而被置为true,也并不是正常的中断。

    疑问2:为什么我写的中断程序没有中断呢?

    1.线程中while条件的需要 自定义标志+中断标志位监测

    2.抛出interruptedException异常后,中断标志位会复位,所以在catch代码块中要有重新置位   

    Thread.currentThread().interrupt();

    注意:在主线程中调用

    th.cancel();

    cancel方法中System.out.println("Thread.currentThread:"+Thread.currentThread().getName());

    Thread.currentThread()对象是主线程(main)--------调用th.cancel()代码的线程,而并不是th这个线程。

    三.不可中断的阻塞,是不响应interrupte中断的,如何让其响应普通的中断?

    java中不可中断的有IO通讯中的inputStream/outputStream的read/write方法,NIO中selector.select()等。

    解决方式:在声明线程中,覆写interrupt()方法,首先关闭底层的套接字,再调用super.interrupt(),因为在关闭套接字的时候,会像interruptedException一样抛出一个异常,我们可以捕获这个异常来进行处理。

    展开全文
  • 文章目录响应线程中断线程的方法使用Interrupt中断线程总结Java异常体系 响应线程中断线程的方法 拥有响应中断信号的能力的方法如下: 能够响应中断信号的能力,代表线程被中断了, 能够感知到该线程被中断了 使用...

    响应线程中断线程的方法

    拥有响应中断信号的能力的方法如下:
    能够响应中断信号的能力,代表线程被中断了, 能够感知到该线程被中断了

    使用Interrupt中断线程总结

    被中断的线程, 自身拥有何时中断的权利 , 因为线程中的某些代码是非常 重要的, 要等到处理完之后,才会进行中断, 或者该线程直接不理会中断的信号.
    不应该鲁莽的使用stop方法, 否则可能会导致数据的丢失.

    Java异常体系

    Java异常体系如下图. 顶层为Throwable.
    接着是Error和 Exception.
    Error 一般为硬件错误, 或其他重大的错误
    Exception 分为运行时异常 和非运行时异常.
    非运行时异常 又叫做受检查的异常, 必须抛出或tra catch

    展开全文
  • 线程中断interrupt

    2019-07-15 17:59:00
    Java 钟的线程中断是一种线程间的协作模式,通过设置线程的中断标志不能直接终止该线程的执行,而是被中断的线程根据状态自行处理。 void interrupt() 方法:中断线程 例如:当线程 A 运行时,线程 B 可以调用线程...
  • 中断状态 每一个线程都有一个boolean属性,表示中断状态,初始值为false。 中断线程:Thread.interrupt() ...如果线程在阻塞状态下,线程将退出阻塞且中断状态将被清除(即为false),且会抛出InterruptException...
  • 线程中断 interrupt

    2021-04-28 15:09:35
    也就是说调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时机中断自己。每个线程都有一个boolean的中断状态(这个状态不在Thread的属性上),interrupt方法仅仅只是将该...
  • 通过volatile修饰的变量来停止线程 package juc; import java.util.concurrent.TimeUnit; /** * @author yanjun.liu * @date 2020/6/28--17:13 */ public class MyInterrupt { public volatile static ...
  • 1.将线程内部的中断变量设置为true。(ps:线程对象内部维护着一个类似isStop的中断变量。) 2.如果线程执行到了阻塞方法,那么该方法通过抛出InterruptedException的形式取消阻塞,并将中断变量重新恢复成false。
  • 使用interrupt方法中断线程

    千次阅读 2017-09-03 23:54:54
    Thread类的interrupt方法是用来中断一个线程的。
  • Thread线程中断interrupt

    2020-08-15 19:29:34
    目录一、线程中断二、中断方法2.1 `interrupt()`2.2 `isInterrupted()`判断目标线程的中断状态2.3 `interrupted()`清除当前中断状态,并且返回之前断值3、小结 一、线程中断 当我们启动一个任务或者一个线程之后,有...
  • interrupt方法中断线程

    2017-09-30 11:15:33
    如何正确地停止一个线程? 停止一个线程意味着在任务处理完任务之前停掉正在做的操作,也就是放弃当前的操作。停止一个线程可以用Thread.stop()方法,但最好不要用它。虽然它确实可以停止一个正在运行的...
  • 线程中断和线程终止线程中断interrupt 线程中断interrupt interrupt() 的作用是中断当前线程
  • Java线程中断interrupt

    2017-10-26 10:40:15
    Java线程中断的本质 本质: JVM设置线程的中断标记,不同于操作系统的抢占式中断;Java线程中断作用 中断处于WAITING、TIMED_WAITING状态的线程,使其抛出中断异常; 设置中断标记位,应用程序通过判断该标记为取消...
  • 线程中断 interrupt 方法怎么理解,意思就是线程中断了吗?那当前线程还能继续执行吗? 判断线程是否中断的方法有几个,它们之间有什么区别? LockSupport的 park/unpark 和 wait/notify 有什么区别? sleep 方法是...
  • }catch (InterruptedException e){} thread.interrupt(); } } class MyThread extends Thread{//第二种创造线程; boolean flag = true; public void run(){ while (flag){ System.out.println("==="+new Date()+"==...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,735
精华内容 1,094
关键字:

interrupt线程中断