zoukankan      html  css  js  c++  java
  • 线程的创建终止和生命周期

    1 线程的创建

    方法1:实现Runnable接口(推荐)

    class Runner1 implements Runnable {
        public void run() {
            for(int i=0; i<30; i++) System.out.println("No. " + i);
        }
    }
    public class TestThread1 {
        public static void main(String args[]) {
            Thread t1 = new Thread(new Runner1());
            t1.start();
        }
    }

    Runable是任务的概念,如果我们直接这样写,会怎么样呢?只会在原来的线程(Main的)里执行run方法。可见Runable更灵活,任务不用写死在线程里,可以放到不同的线程,甚至线程池里运行。把任务和运行分离

    public class TestThread1 {
        public static void main(String args[]) {
            Runnable r1 = new Runner1();
            r1.run();
        }
    }

    方法2:继承Thread

    class Thread1 extends Thread {
        public void run() {
            for(int i=0; i<100; i++) {    
                System.out.println("Runner1 :" + i);
            }
        }
    }
    public class TestThread1 {
        public static void main(String args[]) {
            Thread1 t1 = new Thread1();
            t1.start();
        }
    }

    2 线程的终止

    参考:http://www.cnblogs.com/skywang12345/p/3479949.html

    http://hapinwater.iteye.com/blog/310558

      线程的终止主要有三种方式:

      a. interrupt;

      b. 通过额外标识位;

      c. suspend(暂停),resume(恢复),stop(终止),这三个方法已经过时。suspend和resume就像唱片机,能停能恢复,现在主要被wait/notify取代。stop终止线程太暴力,没时间让线程释放资源,所以被淘汰了。

      这些终止是让别的线程终止自己,因别人启动,因别人终止啊~。要终止自己只要从run方法return就行。

    2.1 interrupt

    每个线程上都有一个标识位interrupted,说明该线程是否被中断。当interrupt()时,只会改标志位,不会真的终止线程。我这里加了一个on标识来关掉这个线程,否则我们就没办法关闭它了。

    class ATask  extends Thread { 
        private volatile boolean on=true;
        
        public void run() {
            while (on) {  
                System.out.println("I am running!");                
                for (int i = 0; i < 10000000; i++);
            }  
        }
        
        public void shutdown(){
            on=false;
        }
    }  
      
    public class TestThread {  
          
        public static void main(String[] args) throws Exception{
            ATask t = new ATask();  
            t.start();  
              
            //运行一断时间中断线程  
            Thread.sleep(20);  
            System.out.println("****************************");  
            System.out.println("Interrupted Thread!");  
            System.out.println("****************************");  
            t.interrupt();
            Thread.sleep(20);
            System.out.println("ShutDown Thread!");  
            System.out.println("****************************");  
            t.shutdown();
        }  
    }   

    运行结果:

    I am running!
    I am running!
    ****************************
    Interrupted Thread!
    ****************************
    I am running!
    I am running!
    ShutDown Thread!
    ****************************

      interrupted可以通过myThread.isInterrupted()查询,也可以通过Thread.interrupted()重置interrupted标志位(设为fasle)。

      java给了线程编写者自由,让他定义在别人中断自己时怎么响应。主要分两种情况,一种是阻塞式的,另一种是非阻塞式。

    a. 阻塞式的:调用了sleep(), wait(), join()等方法就会进入阻塞状态。就是说干什么已经不由线程编写者决定,控制权交到sleep里。这些阻塞方法都会抛InterruptedException异常,我么只要在catch里响应Interrupt。可以向下面乖乖地return,就终止了线程(并释放相应资源);也可以直接不管(catch里什么都不写),这样线程就会继续while下去。这里有个小细节,在抛InterruptedException时,虚拟机会重置interrupted标志位。

    class ATask  extends Thread { 
        public void run() {
            while(true){            
                try {
                    System.out.println("I am running!");
                    sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("ATask.run() interrupted!");
                    return;
                }
            }       
        }  
    } 
    
    
    public class TestThread {
        public static void main(String[] args) throws Exception{  
            //将任务交给一个线程执行  
            Thread t = new ATask();  
            t.start();  
              
            //运行一断时间中断线程  
            Thread.sleep(20);  
            System.out.println("****************************");  
            System.out.println("Interrupted Thread!");  
            System.out.println("****************************");  
            t.interrupt();  
        }
    }

    运行结果:

    I am running!
    ****************************
    Interrupted Thread!
    ****************************
    ATask.run() interrupted!

    b. 非阻塞式方法:不是阻塞式的,控制权在自己手里。

    class ATask  extends Thread { 
        public void run() {  
            //检查程序是否发生中断  
            while (!Thread.interrupted()) {  
                System.out.println("I am running!");
                for (int i = 0; i < 1000000; i++); 
            }
            System.out.println("ATask.run() interrupted!");  
        }  
    } 
    public class TestThread{  
        
        public static void main(String[] args) throws Exception{  
            //将任务交给一个线程执行  
            Thread t = new ATask();  
            t.start();  
              
            //运行一断时间中断线程  
            Thread.sleep(20);  
            System.out.println("****************************");  
            System.out.println("Interrupted Thread!");  
            System.out.println("****************************");  
            t.interrupt();  
        }  
    } 

    运行结果:

    I am running!
    I am running!
    ****************************
    Interrupted Thread!
    ****************************
    ATask.run() interrupted!

    2.2 通过额外标识位

    class ATask  extends Thread {
        private volatile boolean on = true;
        
        public void run() {
            while(on){            
                 System.out.println("I am running!");                
                 for (int i = 0; i < 10000000; i++);
            }
        }
        
        public void shutDown() {
            on = false;
        }
    } 
    
    public class TestThread {
        public static void main(String[] args) throws InterruptedException{  
            //将任务交给一个线程执行  
            ATask t = new ATask();  
            t.start();  
              
            //运行一断时间中断线程  
            Thread.sleep(20);  
            System.out.println("****************************");  
            System.out.println("shutDown Thread!");  
            System.out.println("****************************");  
            t.shutDown();  
        }
    }

    对比2.1,2.2两种方法:

    a 都能 自由地处理其他线程的终止请求;

    b 都能 在终止时释放资源;

    c 2.2不能终止处于阻塞状态的线程。

    3 线程的生命周期

     线程的状态起始很简单,就是启动->运行->终止。等待,超时等待,阻塞都是一种阻塞状态,到用到时在分析,和线程的状态没太多关系,就那么简单。

  • 相关阅读:
    使用静态工厂方法的好处和坏处
    xUtils3源码分析(一):view的绑定
    在laravel之外使用eloquent
    ruby里面的毒瘤
    ruby的代码风格
    ruby里面的属性访问器
    ruby里面module和class的区别
    unity里面查找所有物体
    android studio安装须知
    intellij系列ide配置
  • 原文地址:https://www.cnblogs.com/deliver/p/5678513.html
Copyright © 2011-2022 走看看