现在的位置: 首页 > 综合 > 正文

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

2018年09月16日 ⁄ 综合 ⁄ 共 7100字 ⁄ 字号小中大 ⁄ 评论关闭

--------------------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培训、期待与您交流！ --------------------

【上篇】黑马程序员_<>
【下篇】黑马程序员_<<生产者和消费着>>

作者: catapult

该日志由 catapult 于6年前发表在综合分类下，最后更新于 2018年09月16日.
转载请注明: 黑马程序员_<<线程的一般方法>> | 学步园 +复制链接

抱歉!评论已关闭.

学步园

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

1. 中断线程

1. 概述

2.举例

2. 守护线程

1. 概述

2. 代码举例

3. 等待线程终止

1 . 概述

2. 代码举例

4. 优先级和礼让

1. 优先级

2. 礼让

5. 匿名线程

作者: catapult

书签

最新文章New

本站推荐

返回首页