join线程,后台线程,线程睡眠,线程让步,改变线程优先级

1.join线程

join线程的意思就是在当前这个线程A里,加入另一个线程B,此时A阻塞,进入就绪状态,等B完成(结束,线程死亡),A才会继续执行.

这个方法通常由使用线程的程序调用,用以将大问题划分成许多小问题,每个小问题配一个线程,但所有小问题处理后,再调用主线程进一步操作.

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

package org.credo.thread;   public class Thread_join extends Thread{        public static void main(String[] args) throws InterruptedException {          new Thread_join( "new Thread" ).start();          for ( int i= 0 ;i< 100 ;i++){              if (i== 20 ){                  Thread_join thread= new Thread_join( "by join's Thread." );                  thread.start();                  //main线程调用了jt线程的join方法,main线程必须等jt执行完才能继续执行.                  thread.join();              }              System.out.println(Thread.currentThread().getName()+ " " +i);          }      }            //提供一个有参的构造函数,用于设置线程的名字      public Thread_join(String name){          super (name);      }            public void run(){          for ( int i= 0 ;i< 100 ;i++){              System.out.println(getName()+ " " +i);          }      } }

上面是一个示例方法,是main线程调用了jt的join方法.例子可以直接运行.RUN方法里不要用这种,会死锁.

join有3种重载形式:

• 1.join():等待被join的线程执行完成.
• 2.join(毫秒):等到多少毫秒后不再等待.如果时间内照旧,超过不等.
• 3.join(long 毫秒,int 毫微秒):同上.

2.后台线程

在Java中有一种线程,是在后台运行,任务是为其他线程提供服务,这种线程被称为"后台线程",Daemon Thread,也被叫做"守护线程"或"精灵线程".JVM的垃圾回收线程就是典型的后台线程.他们有个显著的特点就是,如果所有的前台线程都死亡,那么后台线程会自动死亡.

调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程.下面提供一个DEMO.

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package org.credo.thread;   public class Thread_Daemon extends Thread{        public static void main(String[] args) {          Thread_Daemon daemonThread= new Thread_Daemon();          daemonThread.setDaemon( true );          daemonThread.start();          //注意上面的,setDaemon(true)必须在start之前,否则报错.threadStateException.          for ( int i= 0 ;i< 10 ;i++){              System.out.println(Thread.currentThread().getName()+ " " +i);          }      }            public void run(){          for ( int i= 0 ;i< 10000 ;i++){              System.out.println(getName()+ " " +i);          }      }      //可以发现run方法并不会循环1W次,因此,守护线程在前台线程全挂了之后也跟着挂了. }

3.线程睡眠 sleep

路过.........我是打酱油的......javaer都知道吧.......但值得注意的是这是让线程进入阻塞状态,而不是就绪状态.

4.线程让步 yield

它和sleep不同,它让线程进入的是就绪状态,它和sleep一样,是Thread的静态方法.

yield()只是让当前的线程暂停一下,让系统的线程调度器重新调度一次,完全可能存在的情况就是:当某个线程调用了yield()方法暂停之后,线程调度器又将其调度出来重新执行.

实际上,当某个线程调用了yield()方法暂停后,只有优先级与当前线程相同,或者高的线程才会有机会执行.如下code:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package org.credo.thread;   public class Thread_yield extends Thread{        public static void main(String[] args) {          //启动2个并发线程          Thread_yield ty1= new Thread_yield( "Super A--" );          Thread_yield ty2= new Thread_yield( "Super B--" );          ty1.start();          ty2.start();      }            public Thread_yield(String name){          super (name);      }            public void run(){          for ( int i= 0 ;i< 50 ;i++){              System.out.println(getName()+ " " +i);              if (i== 20 ){                  Thread.yield();                  System.out.println( "====================" );              }          }      } }

sleep和yield区别:

1. sleep暂停当前线程后,会给其他线程执行机会,不理会优先级.而yield只会给高级,平级.
2. sleep是将线程转入阻塞状态,而yield是就绪状态.完全可能说是调用yield后,线程管理调度器再把它扔出去执行.
3. sleep申明抛出了InterruptedException(中断异常),而yield木有申明异常.
4. 建议使用sleep来控制并发线程的执行.Over.

5.改变线程优先级

优先级,高的有多的执行机会.每个线程的默认优先级都和创建它的父线程优先级相同.默认情况main线程具有普通优先级.

直接贴代码了,不想写字了.

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package org.credo.thread;   public class PriorityTest extends Thread{        //默认为6.min为1,中间那个NORM_PRIORITY为5,max为6      public static void main(String[] args) {          Thread.currentThread().setPriority( 6 );          for ( int i= 0 ;i< 30 ;i++){              if (i== 10 ){                  PriorityTest low= new PriorityTest( "low" );                  low.start();                  System.out.println( "创建之初的优先级:" +low.getPriority());                  low.setPriority(MIN_PRIORITY);              }              if (i== 20 ){                  PriorityTest high= new PriorityTest( "high" );                  high.start();                  System.out.println( "创建之初的优先级:" +high.getPriority());                  high.setPriority(MAX_PRIORITY);              }          }      }            public PriorityTest(String name){          super (name);      }            public void run(){          for ( int i= 0 ;i< 50 ;i++){              System.out.println(getName()+ ",优先级是:" +getPriority()+ ",循环变量的值为:" +i);          }      } }

一般情况下使用java指定的3个常量来使用最好.