e小白

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
查看: 492|回复: 0

线程(第二部分)

[复制链接]

4

主题

4

帖子

32

积分

新手上路

Rank: 1

积分
32
发表于 2021-6-24 16:22:48 | 显示全部楼层 |阅读模式
本帖最后由 yupic1 于 2021-6-24 16:38 编辑



线程状态



停止线程
  1. 不推荐使用JDk提供的stop()、destory()方法。(已废弃)
  2. 推荐线程自己停下来
  3. 记忆使用一个标志位进行终止变量,当flag=false,则终止线程运行
复制代码
  1. package demo01;

  2. public class test implements Runnable {

  3.     private boolean flag = true;

  4.     @Override
  5.     public void run() {
  6.         int i = 0;
  7.         while (flag){
  8.             System.out.println("run...thread"+i++);
  9.         }
  10.     }

  11.     public void stop(){
  12.         this.flag=false;
  13.     }

  14.     public static void main(String[] args) {

  15.         test test = new test();
  16.         Thread t = new Thread(test);
  17.         t.start();
  18.         for(int i = 0;i<=1000;i++){
  19.             if(i==900){
  20.                 test.stop();
  21.                 System.out.println("线程该停止了...");
  22.             }
  23.             System.out.println("main"+i);
  24.         }
  25.     }
  26. }
复制代码


线程休眠
  • sleep(时间)指定当前线程阻塞的毫秒数;
  • sleep存在异常InterruptedException;
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时,倒计时等
  • 每一个对象都有一个锁,sleep不会释放锁

  1. package demo01;

  2. //模拟倒计时
  3. public class testThread05 {

  4.     public static void main(String[] args) {
  5.         try {
  6.             tenDown();
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.     }

  11.     public static void tenDown() throws InterruptedException {
  12.         int num = 10;
  13.         while(num>=0){
  14.             Thread.sleep(1000);
  15.             System.out.println(num--);
  16.         }
  17.     }
  18. }
复制代码


线程礼让
  • 礼让线程,让当前正在执行的线程暂停,但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu调度,礼让不一定成功!看cpu心情

Join
  • Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞。
  • 可以想象成插队

  1. package demo01;

  2. public class testJoin implements Runnable{

  3.     @Override
  4.     public void run() {
  5.         for (int i = 0;i<1000;i++){
  6.             System.out.println("vip..."+i);
  7.         }
  8.     }

  9.     public static void main(String[] args) throws InterruptedException {

  10.         //启动我们的线程
  11.         testJoin testJoin = new testJoin();
  12.         Thread thread = new Thread(testJoin);
  13.         thread.start();

  14.         //主线程
  15.         for (int i = 0;i<500;i++){
  16.             if (i==200) {
  17.                 thread.join();
  18.             }
  19.             System.out.println("main..."+i);
  20.         }
  21.     }
  22. }
复制代码


线程状态观测
  • Thread.State



  1. package demo01;

  2. //观察测试线程的状态
  3. public class testState {

  4.     public static void main(String[] args) {

  5.         Thread thread = new Thread(()->{
  6.             //等待(阻塞)5秒
  7.             for (int i = 0; i < 1; i++) {
  8.                 try {
  9.                     Thread.sleep(1000);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  14.             System.out.println("/////////");
  15.         });

  16.         //观察状态
  17.         Thread.State state = thread.getState();
  18.         System.out.println(state); //NEW

  19.         //观察启动后
  20.         thread.start();//启动线程
  21.         state = thread.getState();
  22.         System.out.println(state); //RUN

  23.         while(state != Thread.State.TERMINATED){ //只要线程不终止,就一直输出状态
  24.             try {
  25.                 Thread.sleep(100);
  26.                 state = thread.getState();//更新状态
  27.                 System.out.println(state);
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  33. }
复制代码

创建线程后处于NEW状态,调用start方法后处于RUNNABLE(就绪)状态,等待cpu调度,调用sleep方法后处于WAITING(阻塞)状态,线程结束后处于TERMINATED(死亡)状态。

线程优先级
  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示,范围从1~10
  • 使用以下方式改变或获取优先级
  • getPriority().setPriority(int xxx)

  1. package demo01;

  2. public class testPriority {

  3.     public static void main(String[] args) {

  4.         //主线程默认优先级
  5.         System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

  6.         myPriority myPriority = new myPriority();

  7.         Thread t1 = new Thread(myPriority);
  8.         Thread t2 = new Thread(myPriority);
  9.         Thread t3 = new Thread(myPriority);
  10.         Thread t4 = new Thread(myPriority);
  11.         Thread t5 = new Thread(myPriority);
  12.         Thread t6 = new Thread(myPriority);

  13.         //先设置优先级,再启动
  14.         t1.start();

  15.         t2.setPriority(1);
  16.         t2.start();

  17.         t3.setPriority(4);
  18.         t3.start();

  19.         t4.setPriority(Thread.MAX_PRIORITY);
  20.         t4.start();

  21.     }
  22. }

  23. class myPriority implements Runnable{

  24.     @Override
  25.     public void run() {
  26.         System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
  27.     }
  28. }
复制代码
优先级低只是意味着获得调度的概率低,并不是优先级低就不会调用了,看cpu心情。

守护线程
  • 线程分为用户线程守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如后台记录操作日志,监控内存,垃圾回收等待

  1. package demo01;

  2. public class testDeamon {

  3.     public static void main(String[] args) {

  4.         God god = new God();
  5.         You you = new You();

  6.         Thread thread = new Thread(god);
  7.         thread.setDaemon(true);//默认是false表示用户线程,正常的线程都是用户线程

  8.         thread.start();//上帝守护线程启动

  9.         new Thread(you).start();//你 用户线程启动...      

  10.     }
  11. }

  12. class You implements Runnable{

  13.     @Override
  14.     public void run() {
  15.         for (int i = 0; i < 36500; i++) {
  16.             System.out.println("开心每一天");
  17.         }
  18.         System.out.println("<=========goodbye world===========>");
  19.     }
  20. }

  21. class God implements Runnable{

  22.     @Override
  23.     public void run() {
  24.         while(true){
  25.             System.out.println("上帝忽悠着你");
  26.         }
  27.     }
  28. }
复制代码




由于上帝线程是保护线程,虚拟机不会管保护线程是否执行完,只管用户线程,所以在you线程执行完后,god线程也就会结束。上帝跑了一会是因为虚拟机停止需要一定时间。

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|e小白

GMT+8, 2021-9-25 14:26 , Processed in 0.423304 second(s), 21 queries .

Powered by Discuz! X3.4

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表