高洪岩--多线程

一、线程状态

1)综述： 线程终止三种方法： 1、使用退出标志，使线程正常退出，也就是当run方法完成线程终止； 2、使用stop方法强行终止线程（不推荐使用），因为stop和suspend及resume数据过期方法，可能产生不可预料结果； 3、使用interrupt方法中断线程   2)概念、案例及实战引入： Interrupt()：该方法使用效果不像for+break，马上停止循环，调用interrupt()仅仅是在当前线程中打一个停止标记，并不真的停止线程。 总结： （1）this.interrupted()：测试当前线程是否已经中断，执行后具有将状态标志清除为false的功能 （2）this.isInterrupted()：测试线程是否已经中断，但不清除状态标志 publicclass InterruptThread extends Thread{      @Override    publicvoid run() {       for(inti = 0 ; i<5000 ; i++){           System.out.println("i==="+i);           //this.interrupt()           //在线程中执行interrupt()都无法终止线程执行       }    } }      publicstaticvoid main(String[] args) {       InterruptThread td = new InterruptThread();       td.start();       try {           Thread.sleep(2000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       td.interrupt();    } 解析：线程并不会因为interrupt()调用而终止或者卡顿，只会继续执行！   判断线程是否停止状态（this.interrupted 测试当前线程是否已经中断；this.isInterrupted测试线程是否已经中断） publicclass ThisInterruptedThread extends Thread{    @Override    publicvoid run() {       for(inti = 0; i<50000 ; i++){           System.out.println("i---->"+i);       }    } }   publicclass ThisInterruptedThreadRn {    publicstaticvoid main(String[] args) {       ThisInterruptedThread td = new ThisInterruptedThread();       td.start();       try {           Thread.sleep(1000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       td.interrupt();       Thread.currentThread().interrupt();       System.out.println("线程是否终止："+Thread.interrupted());       //true interrupted只是标识当前线程，也就是主线程终止标志       System.out.println("线程是否终止："+td.interrupted());       //false interrupted不能获取到子线程结束标志       System.out.println("线程是否终止："+Thread.interrupted());       //false 官方文档解释：如果当前线程连续两次调用interrupted()方法，       //则第一次调用已经清除了中断状态，第二次调用则为false了。          } } 解析：interrupt()并不能中断线程，同时interruptted()方法只能中断当前所在线程，不能中断其他线程，连续执行时第一次会清除中断的标识。 Break，中断执行（只能中断循环，不能中断线程执行及后续代码执行） publicclass ExceptionThread extends Thread{    @Override    publicvoid run() {       for(inti = 0 ; i<5000; i++){           if(this.isInterrupted()){              System.out.println(i+"---------线程可以终止");              break;           }           System.out.println("i-->"+i);       }       System.out.println("线程被interrupt后还能执行该代码");       for(intj =0 ; j<100; j++){           System.out.println("线程break interrupt之后:"+j);       }    }    }   publicclass ExceptionThreadRn {      publicstaticvoid main(String[] args) {       ExceptionThread et = new ExceptionThread();       et.start();       try {           Thread.sleep(10);       } catch (InterruptedException e1) {           // TODO Auto-generated catch block           e1.printStackTrace();       }       et.interrupt();       try {           Thread.sleep(1000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }          } } 解析：子线程内通过isInterrupted()判断后，只会中断当前的循环，后续的代码逻辑和再次的一个循环代码还会继续执行。 在沉睡中终止线程： publicclass SleepThread extends Thread{    @Override    publicvoid run() {       System.out.println("thread start");       try {           Thread.sleep(1000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           System.out.println("子线程是否被终止："+this.interrupted());           e.printStackTrace();       }       System.out.println("thread end");          } } publicclass SleepThreedRn {    publicstaticvoid main(String[] args) {       SleepThread st = new SleepThread();       st.start();       try {           Thread.sleep(500);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       st.interrupt();    } } 结果： 解析：如果在sleep状态下终止某一个线程，会进入catch操作，并且清除线程终止状态，然后线程状态为false。 线程停止----暴力停止stop publicclass StopThread extends Thread{    @Override    publicvoid run() {       inti = 0;       while(i <5999999){           i ++;           System.out.println("当前运行结果："+i);       }       System.out.println("线程被终止");    } } publicclass StopThreadRn {    publicstaticvoid main(String[] args) {       StopThread st = new StopThread();       st.start();       try {           Thread.sleep(500);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       st.stop();    } } 结果： 解析：stop()执行之后，线程立刻中断，不会执行任何代码！同时该方法已经被作废，如果强制线程终止可能有一些清理性工作得不到完成；另外一个就是对锁定的对象进行解锁，导致数据得不到同步处理，出现数据不一致。 数据不一致案例： publicclass StopTipInfo {    private String usernanme ="uaa";    private String password = "paa";    public String getUsernanme() {       returnusernanme;    }    publicvoid setUsernanme(String usernanme) {       this.usernanme = usernanme;    }    public String getPassword() {       returnpassword;    }    publicvoid setPassword(String password) {       this.password = password;    }    publicsynchronizedvoid printInfo(String username,String password){ //    System.out.println("username = "+username+",password="+password);       this.usernanme = username;       try {           Thread.sleep(5000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       this.password = password;    } } publicclass StopTipThread extends Thread{    private StopTipInfo stopTipInfo;    public StopTipThread(StopTipInfo stopTipInfo){       this.stopTipInfo = stopTipInfo;    }    @Override    publicvoid run() {       stopTipInfo.printInfo("cc", "pcc");    } } publicclass StopTipInfoRn {    publicstaticvoid main(String[] args) {       StopTipInfo info = new StopTipInfo();       StopTipThread st = new StopTipThread(info);       st.start();       try {           Thread.sleep(500);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       st.stop();       System.out.println("username = "+info.getUsernanme()+",password="+info.getPassword());    } } 结果：username = cc,password=paa 解析：stop()方法导致同步线程数据出现不一致性。 Interrupt()+return;完成线程内部业务中断： publicclass ReturnThread extends Thread{    @Override    publicvoid run() {       inti = 0;       while(true){           i ++;           System.out.println("i==>"+i);           if(Thread.interrupted()){              System.out.println("线程停止----");              return ;           }           System.out.println("---->");       }    } } publicclass ReturnThreadRn {    publicstaticvoid main(String[] args) {       ReturnThread rt = new ReturnThread();       rt.start();       try {           Thread.sleep(100);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       rt.interrupt();    } } 解析：实现子线程中断，后续业务不再持续进行；建议使用异常抛出手段来解决子线程中断问题。

二、多线程变量并发访问

案例一：成员变量（实例变量）和普通（方法内）变量区别 publicclass HasSelfPrivateNum {    privateintindex = -1;//成员变量    publicvoid addI(String username){       try {           intnum = 0;//方法内变量           if(username.equals("a")){              num = 100;              index = 1111;              System.out.println("a is set over 100");              Thread.sleep(2500);           }else{              num = 200;              index = 222;              System.out.println("b is set over 200");           }           System.out.println("username = "+username +",num = "+num+"---->index="+index);       } catch (Exception e) {           thrownew RuntimeException(e);       }    } }   publicclass ThreadA extends Thread{      private HasSelfPrivateNum has;    public ThreadA(HasSelfPrivateNum has){       this.has = has;    }    @Override    publicvoid run() {       has.addI("a");    } }   publicclass ThreadB extends Thread {    private HasSelfPrivateNum has;    public ThreadB(HasSelfPrivateNum has){       this.has = has;    }    @Override    publicvoid run() {       this.has.addI("b");    } }   publicclass HasSelfPrivateNumRn {    publicstaticvoid main(String[] args) {       HasSelfPrivateNum has = new HasSelfPrivateNum();       ThreadA a = new ThreadA(has);       ThreadB b = new ThreadB(has);             a.start();       b.start();    } } 结果： 解析：因为方法内都是各自线程自我调用，没有共同资源；成员变量出现了（公共资源），因为线程共同访问+沉睡，导致了错误，同时多线程的调用导致了整个打印的错乱。 ------- 案例二：方法级别同步，保证线程安全性 修改：在HasSelfPrivateNum类中的addI()方法加上synchronized关键字，产生正确结果（同时造成线程的堵塞）。多个线程同时持有一个对象的锁，看线程强占速度，所以日志没有交叉，数据正确。 结果【实现线程安全】： 案例三：多个对象多个锁 publicclass HasSelfPrivateNumRn2 {    publicstaticvoid main(String[] args) {       HasSelfPrivateNum t1 = new HasSelfPrivateNum();       HasSelfPrivateNum t2 = new HasSelfPrivateNum();       ThreadA a = new ThreadA(t1);       ThreadB b = new ThreadB(t2);             a.start();       b.start();    } } 结果： 解析：声明了t1和t2两个对象，在a线程中调取t1对象，拥有的是t1对象的锁，而b线程中调取t2对象，拥有的是t2对象的锁。关键字synchronized取得的锁都是对象锁，这样他们就互不影响，t1和t2的信息都保存在自己的线程栈中，对其他线程不可见，所有a和b并发执行(log交叉)。 案例四：类锁【继续修改上述案例】 publicclass HasSelfPrivateNum {    privatestaticintindex = -1;//静态化    //方法静态化    publicstaticsynchronizedvoid addI(String username){       try {           intnum = 0;           if(username.equals("a")){              num = 100;              index = 1111;              System.out.println("a is set over 100");              Thread.sleep(2500);           }else{              num = 200;              index = 222;              System.out.println("b is set over 200");           }           System.out.println("username = "+username +",num = "+num+"---->index="+index);       } catch (Exception e) {           thrownew RuntimeException(e);       }    } } 结果： 解析：如果在addI方法上加上static关键字，，表示锁定class类。不管声明多少个MultiThread引用，printNum方法跟随类存放在堆上，线程间会共享资源，输出结果会等m1信息输出结束之后才会开始输出m2信息。 总结：一个对象一把锁（实现对象上互斥）；在静态方法上synchronized代表的是类的锁（实现类上互斥）。 案例五： publicclass ThreeSynchronizedTask {    publicsynchronizedvoid printA(){       System.out.println(Thread.currentThread().getName()+"--printA--"+System.currentTimeMillis());    }       publicsynchronizedvoid printB(){       try {           Thread.sleep(2000);       } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();       }       System.out.println(Thread.currentThread().getName()+"--printB--"+System.currentTimeMillis());    }    publicsynchronizedvoid printC(){       System.out.println(Thread.currentThread().getName()+"--printC--"+System.currentTimeMillis());    } } publicclass Ta extends Thread{    private ThreeSynchronizedTask task;    public Ta(ThreeSynchronizedTask task){       this.task = task;    }    @Override    publicvoid run() {       task.printA();       task.printB();       task.printC();    } } publicclass Tb extends Thread{    private ThreeSynchronizedTask task;    public Tb(ThreeSynchronizedTask task){       this.task = task;    }    @Override    publicvoid run() {       task.printA();       task.printB();       task.printC();    } } publicclass ThreeSynchronizedTaskRn {    publicstaticvoid main(String[] args) {       ThreeSynchronizedTask task = new ThreeSynchronizedTask();       Ta a = new Ta(task);       a.setName("A");       Tb b = new Tb(task);       b.setName("B");             a.start();       b.start();    } } 结果： 解析： 线程强占锁之后，执行synchronized方法，然后如果有持续的synchronized方法会继续持有，否则释放掉抢占的锁。也会出现线程交替执行的程序。

三、volatile关键字

作用：用户多个线程之间实现修饰符变量可见。