黑马程序员_<<线程的一般方法>>

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

1. 中断线程

        1. 概述

                    使用的是interrupt()方法

       线程在运行的时候受到了阻碍，那么可以使其在受阻状态强制回到运行状态，是线程中断现有的状态。

       一般线程都是循环执行语句，要是改变循环的标识的话，就可以结束程序，但是这样会结束线程，但是中断的话，就是中止当前线程冻结状态，恢复正常执行。

       使用了Interrupt()后，那么重新运行，也可能会再次进入冻结状态。那么就是发生了异常的那里。更改标识，那么最后就会正常的结束线程。

        2.举例

      

 public 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()
             + "::::Exception");
         this.flag = false;// 改变标记，是线程正常的结束
      }
      System.out.println(Thread.currentThread().getName() + "-------run");
 
    }
 
  }
 
  public void changeFlag() {
    this.flag = false;
  }
 
}
/*测试类*/
public class Text {
  public static void main(String[] agrs) {
    StopThread st = new StopThread();
    Thread t1 = new Thread(st);
    Thread t2 = new Thread(st);
    t1.start();
    t2.start();
    for (int i = 0; i < 200; i++) {
      if (i == 100) {
         // st.changeFlag();
         t1.interrupt();//中断线程，终止冻结状态
         t2.interrupt();//中止冻结状态
         break;
      }
 
      System.out.println(Thread.currentThread().getName() + "-------run");
    }
    System.out.println("over");
  }
}
结果：
main-------run
main-------run
main-------run
main-------run
over
Thread-0::::Exception
Thread-0-------run
Thread-1::::Exception
Thread-1-------run
 

2. 守护线程

       1.  概述

         利用：setDaemom(boolean bo)将线程标记为守护线程，当正在运行的程序都是守护线程的时候，java虚拟机会自动退出。

         要在线程开启前，将线程标记为守护线程。

         通俗的讲：后台线程，后台线程依赖于前台线程，当前台线程结束后，后台线程会自动的结束。

       2. 代码举例

         当不标记为守护线程的时候，他们交替运行(CPU被抢夺)

  

public class ProThreadimplements Runnable {
 
  public void run() {
    for(int i=0;i<50;i++){
      System.out.println(Thread.currentThread().getName()+"--run:"+i);
    }
  }
}
/*测试类*/
public class Text {
  public static void main(String[] agrs) {
    ProThread st = new ProThread();
    new Thread(st).start();
    new Thread(st).start();
    for (int i = 0; i < 50; i++) {
      System.out.println(Thread.currentThread().getName() + "--run:" + i);
    }
    System.out.println("over");
  }
}
结果：
Thread-0--run:0
Thread-1--run:0
main--run:0
Thread-1--run:1
Thread-0--run:1
Thread-1--run:2
main--run:1
Thread-1--run:3

      从结果可以看出，他们之间抢夺CPU，抢到后就开始执行，交替运行

 

 

   标记为守护线程

       

public class ProThread implements Runnable {
  public void run() {
    for(int i=0;i<50;i++){
      System.out.println(Thread.currentThread().getName()+"--run:"+i);
    }
 
  }
}
/*测试类*/
public class Text {
  public static void main(String[] agrs) {
    ProThread st = new ProThread();
    Thread t1=new Thread(st);
    Thread t2=new Thread(st);
    t1.setDaemon(true);//设置为守护线程
    t2.setDaemon(true);//设置为守护线程
    t1.start();//线程启动
    t2.start();//线程启动
    for (int i = 0; i < 50; i++) {
      System.out.println(Thread.currentThread().getName() + "--run:" + i);
    }
    System.out.println("over");
  }
}
部分结果：
main--run:47
main--run:48
main--run:49
over
Thread-1--run:28
Thread-1--run:29
Thread-1--run:30
Thread-1--run:31
Thread-1--run:32
Thread-1--run:33
Thread-1--run:34

 

        从结果可以看出，当主线程运行结束后(前台线程)，后台线程即使没有运行结束，也会结束，因为此时虚拟机已经退出。

        Over出现了。Thread-1--run:34线程1才执行到34就结束了。这就可以说明，后台线程依赖于前台线程，只要前台线程一结束，那么守护线程就会被迫结束。

 

3. 等待线程终止

         1 . 概述

           等待线程终止使用的是join()方法，必须放在线程开启开启之后，才能起作用。当正在运行的线程(B)执行到线程(A)的join方法，那么线程(B)就处于冻结状态。直到等到线程(A)，运行结束后，那么线程B才能解决冻结状态。

         2. 代码举例

  

 public class JoinThread implements Runnable {
  public void run() {
    for(int i=0;i<10;i++){
      System.out.println(Thread.currentThread().getName()+"---"+i);   }
  }
}
public class JoinDemo {
  public static void main(String[] args) throws InterruptedException {
    JoinThread t = new JoinThread();
    Thread t1 = new Thread(t, "线程A");
    Thread t2 = new Thread(t, "线程B");
    t1.start();//开启线程A
    t1.join();//是线程等待终止
    t2.start();//开启线程B
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + "---" + i);
    }
  }
 
}
 

        这个程序是：主线程拥有执权，但是遇到了t1.join()，所有主线程放弃了执行权，处于冻结状态，直到等到线程A运行结束，主线程才结束冻结状态，然后主线程和其他运行的线程交替抢夺CPU，开始继续执行。

4. 优先级和礼让

1. 优先级

       可以设置线程的优先级：优先级是从1~10，系统中定义了三个优先级常量：MAX_PRIORITY(优先级10)，MIN_PRIORITY(优先级5)，NORM_PRIORITY(优先级1),优先级高的抢夺CPU的频率高，但是也会执行其他的优先级低的线程。使用setPriority(整数)方法设置线程的优先级。

     例如设置优先级是2，setPriority(2)

public class yxjThread implements Runnable {
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().toString() + "---" + i);
		}
	}
}
/*测试类*/
public class Text {
	public static void main(String[] agrs) {
		yxjThread t=new yxjThread();
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		t1.setPriority(Thread.MAX_PRIORITY);//将线程A设置为最大优先级10
		t2.setPriority(Thread.MIN_PRIORITY);//将线程A设置为最小优先级1
		t1.start();
		t2.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().toString() + "---" + i);
		}
	}
}

Thread[Thread-0,10,main]---0
Thread[Thread-0,10,main]---1
Thread[main,5,main]---0
Thread[Thread-0,10,main]---2
Thread[main,5,main]---1
Thread[Thread-0,10,main]---3
Thread[main,5,main]---2
Thread[main,5,main]---3
Thread[main,5,main]---4
Thread[Thread-0,10,main]---4
Thread[main,5,main]---5
Thread[Thread-1,1,main]---0
Thread[main,5,main]---6
Thread[Thread-0,10,main]---5
Thread[main,5,main]---7
Thread[Thread-1,1,main]---1
Thread[main,5,main]---8
Thread[main,5,main]---9
Thread[Thread-0,10,main]---6
Thread[Thread-0,10,main]---7
Thread[Thread-0,10,main]---8
Thread[Thread-0,10,main]---9
Thread[Thread-1,1,main]---2
Thread[Thread-1,1,main]---3
Thread[Thread-1,1,main]---4
Thread[Thread-1,1,main]---5
Thread[Thread-1,1,main]---6
Thread[Thread-1,1,main]---7
Thread[Thread-1,1,main]---8
Thread[Thread-1,1,main]---9

从结果可以看出优先级高的，在开始执行的次数比较多，但还会有其他的线程执行，

     2. 礼让

   就是停止当前执行的线程，然后运行其他的线程，把执行权让给其他线程。

 

public class yieldDemo implements Runnable {
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().toString()+ "---" + i);
      Thread.yield();//线程礼让，不执行权让给其他线程
    }
  }
}
/*测试类*/
public class Text {
  public static void main(String[] agrs) {
    yieldDemo t = new yieldDemo();
    Thread t1 = new Thread(t, "线程A");
    Thread t2 = new Thread(t, "线程B");
    t1.start();// 开启线程A 
    t2.start();// 开启线程B
  }
}
 
这样结果就很大可能出现交互执行的现象
Thread[线程A,5,main]---0
Thread[线程B,5,main]---0
Thread[线程A,5,main]---1
Thread[线程B,5,main]---1
Thread[线程A,5,main]---2
Thread[线程B,5,main]---2
Thread[线程A,5,main]---3
Thread[线程B,5,main]---3
Thread[线程A,5,main]---4
Thread[线程B,5,main]---4
Thread[线程A,5,main]---5
Thread[线程B,5,main]---5
Thread[线程A,5,main]---6
Thread[线程B,5,main]---6
Thread[线程A,5,main]---7
Thread[线程B,5,main]---7
Thread[线程A,5,main]---8
Thread[线程B,5,main]---8
Thread[线程A,5,main]---9
Thread[线程B,5,main]---9

5.  匿名线程

   

public class Text {
  public static void main(String[] agrs) {
    /*匿名线程继承的是Thread类*/
    new Thread(){
      public void run(){
         for (int i = 0; i < 10; i++) {
           System.out.println(Thread.currentThread().toString()+ "---" + i);       
         }
      }
    }.start();
    /*主线程执行的部分代码*/
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().toString() + "---" + i);        
    }
    /*内部类，继承Runnable接口*/
    Runnable r=new Runnable(){
      public void run(){
         for (int i = 0; i < 10; i++) {
           System.out.println(Thread.currentThread().toString()+ "---" + i);       
         }
      }
    };
    new Thread(r).start();//开启线程
  }
}
 
结果：
Thread[main,5,main]---0
Thread[Thread-0,5,main]---0
Thread[main,5,main]---1
Thread[Thread-0,5,main]---1
Thread[main,5,main]---2
Thread[Thread-0,5,main]---2
Thread[main,5,main]---3
Thread[Thread-0,5,main]---3
Thread[main,5,main]---4
Thread[Thread-0,5,main]---4
Thread[main,5,main]---5
Thread[Thread-0,5,main]---5
Thread[main,5,main]---6
Thread[Thread-0,5,main]---6
Thread[main,5,main]---7
Thread[Thread-0,5,main]---7
Thread[main,5,main]---8
Thread[Thread-0,5,main]---8
Thread[main,5,main]---9
Thread[Thread-0,5,main]---9
Thread[Thread-1,5,main]---0
Thread[Thread-1,5,main]---1
Thread[Thread-1,5,main]---2
Thread[Thread-1,5,main]---3
Thread[Thread-1,5,main]---4
Thread[Thread-1,5,main]---5
Thread[Thread-1,5,main]---6
Thread[Thread-1,5,main]---7
Thread[Thread-1,5,main]---8
Thread[Thread-1,5,main]---9

 --------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------