疯狂Java学习笔记（64）------------线程转换

线程的生命周期

由上图可以看出：

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。

各个状态细节不再赘述，具体请看http://blog.csdn.net/u011225629/article/details/46288995此篇博文

此篇博文主要讲述各个状态的实例！

一、新建和就绪状态

此处不做细致的讲解，在上一篇博文中已经讲解过了！

      [java] view plain copy
      package com.haixu.thread2;
      public class InvokeRun extends Thread{
         /*
       * 新建就绪状态练习
       * 通过继承Thread类来创建线程
       * */
         private int i;
         public void run(){
             for(; i<5; i++){
                 //直接调用run()方法是，Thread的this.getName（）返回的是该对象的名字 
                 //使用Thread.currentThread().getName（）调用当前线程获取线程名字 
                  System.out.println(Thread.currentThread().getName() + " " + i);
              }
          }
         public static void main(String[] args) {
             for(int i=0; i<4; i++){
                 //使用Thread.currentThread().getName（）调用当前线程获取线程名字 
                  System.out.println(Thread.currentThread().getName() + " " + i);
                 if(i == 3){
                     new InvokeRun().start();
                 //直接调用线程对象的run（）方法 
                     new InvokeRun().run();
                     new InvokeRun().start();
                  }
              }
          }
      }
  
 

      /**
      * 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
      *
      * @author leizhimin 2008-9-14 9:53:49
      */
      public class MyThread extends Thread {
         public void run() {
             for (int i = 0; i < 100; i++) {
                 if ((i) % 10 == 0) {
                      System.out.println("-------" + i);
                  }
                  System.out.print(i);
                 try {
                      Thread.sleep(1);
                      System.out.print(" 线程睡眠1毫秒！\n");
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
         public static void main(String[] args) {
             new MyThread().start();
          }
      }
  
 

      package com.haixu.thread2;
      import java.util.Date;
      public class SleepTest {
      public static void main(String[] args) throws Exception{
       for( int i=0; i<5; i++){
         System.out.println("当前的时间：" + new Date());
         Thread.sleep(1000);
        }
       }
      }
  
 

运行结果：

      当前的时间：Sun May 31 17:59:25 CST 2015
      当前的时间：Sun May 31 17:59:26 CST 2015
      当前的时间：Sun May 31 17:59:27 CST 2015
      当前的时间：Sun May 31 17:59:28 CST 2015
      当前的时间：Sun May 31 17:59:29 CST 2015
  
 

2、线程的优先级和线程让步yield()

      package com.haixu.thread2;
      /*
       * 使用Yield对线程让步，是正在执行的线程停止
       *
       */
      public class YieldTest extends Thread{
         public YieldTest(String name){
             super(name);
          }
         //定义run（）作为执行体 
         public void run(){
             for( int i=0; i<6; i++){
                  System.out.println(getName() + " " + i);
                 //当i=4时线程做出让步 
                 if(i==4){
                      Thread.yield();
                  }
              }
          }
         public static void main(String[] args) {
         //启动两个并发线程 
             YieldTest yt = new YieldTest("高级");
              yt.setPriority(Thread.MAX_PRIORITY);
              yt.start();
             //将此线程设置成低权限 
             YieldTest yt1 = new YieldTest("低级");
              yt1.setPriority(Thread.MIN_PRIORITY);
              yt1.start();
          }
      }
  
 

       高级  0
       高级  1
       高级  2
       高级  3
       低级  0
       低级  1
       低级  2
       低级  3
       高级  4
       高级  5
       低级  4
       低级  5
   
  

       package com.haixu.thread2;
       /*
        * 当调用其他线程的join方法时，调用线程被阻塞
        * 直到被join方法加入的线程执行完为止
        *
        */
       public class JoinTest extends Thread{
       //提供有参数的构造器，用于设置线程的名称 
       public JoinTest(String name){
        super(name);
        }
       public void run(){
        for(int i = 0; i<6; i++){
          System.out.println(getName() + " " + i);
         }
        }
       public static void main(String[] args) throws InterruptedException {
        //启动子线程 
        new JoinTest("新线程").start();
        for(int i=0; i< 5; i++){
         if(i == 2){
          JoinTest jt = new JoinTest("被Join的线程");
           jt.start();
          //main线程调用了jt线程的join方法，main线程 
          //必须等jt之行结束才会向下执行 
           jt.join();
          }
          System.out.println(Thread.currentThread().getName() + " " + i);
         }
        }
       }
   
  

       main  0
       main  1
       新线程 0
       新线程 1
       新线程 2
       新线程 3
       新线程 4
       新线程 5
       被Join的线程 0
       被Join的线程 1
       被Join的线程 2
       被Join的线程 3
       被Join的线程 4
       被Join的线程 5
       main  2
       main  3
       main  4
   
  

文章来源: brucelong.blog.csdn.net，作者：Bruce小鬼，版权归原作者所有，如需转载，请联系作者。

原文链接：brucelong.blog.csdn.net/article/details/79988449