黑马程序员技术交流社区

标题: 多线程之线程控制总结 [打印本页]
作者: a80C51    时间: 2015-9-24 23:47
标题: 多线程之线程控制总结
1)join()线程控制线程
A，定义——一个线程等待另一个线程完成的方法
B，当在某个程序执行流中，调用其他线程的join()方法时，调用线程将会被阻塞，直到被join()方法加入的join线程执行完成为止
C，join()方法的三种重载形式：
        1st，join()——等待被join的线程执行完成
        2nd，join(long millis)——等待被join的线程的时间最长为millis毫秒。如果在millis毫秒内被join的线程还没有执行结束，则不会在等待。
        3rd，join(long millis,int nanos)——等待被join的线程的时间最长为millis毫秒+nanos毫微秒。
D，代码示例如下：
  1. package com.wayne.thread;

  3. public class MyJoinThread extends Thread {
  4.         public MyJoinThread(String name)
  5.         {
  6.                 super(name);
  7.         }
  8.        
  9.         @Override
  10.         public void run() {
  11.                 // TODO Auto-generated method stub
  12.                 for(int i= 0;i<100;i++)
  13.                 {
  14.                         System.out.println(getName()+" "+ i);
  15.                 }
  16.         }
  17.        
  18.         public static void main(String[] args) throws InterruptedException
  19.         {
  20.                 //创建并启动一个名为“新线程”的线程
  21.                 new MyJoinThread("新线程").start();
  22.                
  23.                 for(int i=0;i<100;i++)
  24.                 {
  25.                         System.out.println(Thread.currentThread().getName()+" "+i);
  26.                        
  27.                         if(i == 20)
  28.                         {
  29.                                 //创建一个名为“另外一个阻止main线程的线程”的myJoinThread线程
  30.                                 MyJoinThread myJoinThread = new MyJoinThread("另外一个阻止main线程的线程");
  31.                                
  32.                                 //启动该myJoinThread线程
  33.                                 myJoinThread.start();
  34.                                
  35.                                 //因为main线程调用了myJoinThread线程的join方法，
  36.                                 //故main线程被阻塞，需要等到myJoinThread线程执行完毕后，才能重新恢复运行
  37.                                 myJoinThread.join();
  38.                         }
  39.                 }
  40.         }
  41. }
复制代码


2）通过后台进程控制线程
A，定义：在后台运行的，为其他的线程提供服务的线程。
B，别名：“守护线程”或者“精灵线程”。
C，特征：如果所有的前台线程都死亡，后台线程会自动死亡。
D，调用Thread对象的setDaemon（true）方法可将指定线程设置成后台线程。
E，Thread类提供了一个isDaemon()方法判断指定线程是否为后台线程。
F，前台创建的子线程默认是前台线程，后台创建的子线程默认是后台进程。
G，代码示例如下
  1. package com.wayne.thread;

  3. public class MyDaemonThread extends Thread {
  4.         @Override
  5.         public void run() {
  6.                 // TODO Auto-generated method stub
  7.                 for(int i = 0;i<1000;i++)
  8.                 {
  9.                         System.out.println(getName()+" "+i);
  10.                 }
  11.         }
  12.        
  13.         public static void main(String[] args)
  14.         {
  15.                 MyDaemonThread myDaemonThread = new MyDaemonThread();
  16.                
  17.                 myDaemonThread.setName("后台进程");
  18.                
  19.                 myDaemonThread.setDaemon(true);
  20.                
  21.                 myDaemonThread.start();
  22.                
  23.                 for(int i = 0;i<100;i++)
  24.                 {
  25.                         System.out.println(Thread.currentThread().getName()+" "+i);
  26.                 }
  27.                
  28.                
  29.         }
  30. }
复制代码


3）线程睡眠sleep
A，sleep()方法的两种重载形式
        1st，static void sleep(long millis)
                让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
        2nd，static void sleep(long millis,int nanos)
                让当前正在执行的线程暂停millis毫秒+nanos毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
B，调用sleep()方法进入阻塞状态后，在睡眠时间内，不会获得执行机会，即使系统没有其他可以执行的线程。
C，代码示例如下
  1. package com.wayne.thread;

  3. public class MySleepThread {
  4.        
  5.         public static void main(String[] args) throws InterruptedException {
  6.                 for(int i = 0;i<10;i++)
  7.                 {
  8.                         System.out.println("灯");
  9.                         Thread.sleep(1000);
  10.                 }
  11.         }

  13. }
复制代码


4）线程让步yield()
A，作用：让当前正在执行的线程暂停，将该线程转入就绪状态，并不会进入阻塞状态。
B，当线程调用yeild()方法暂停后，只有优先级与当前线程相同或者比当前线程更高的处于就绪状态的线程才会获得执行机会。
C，代码示例如下
  1. package com.wayne.thread;

  3. public class MyYieldThread extends Thread {
  4.        
  5.         public MyYieldThread(String name)
  6.         {
  7.                 super(name);
  8.         }
  9.        
  10.         @Override
  11.         public void run() {
  12.                 // TODO Auto-generated method stub
  13.                 for(int i = 0;i<100;i++)
  14.                 {
  15.                         System.out.println(getName()+" "+i);
  16.                        
  17.                         if(i == 20)
  18.                                 Thread.yield();
  19.                 }
  20.         }

  22.         public static void main(String[] args) {
  23.                 // TODO Auto-generated method stub
  24.                
  25.                 MyYieldThread myYieldThread1st = new MyYieldThread("yieldThread1st");
  26.                 myYieldThread1st.setPriority(Thread.MAX_PRIORITY);
  27.                 myYieldThread1st.start();
  28.                
  29.                 MyYieldThread myYieldThread2nd = new MyYieldThread("yieldThread2nd");
  30.                 myYieldThread2nd.setPriority(Thread.MIN_PRIORITY);
  31.                 myYieldThread2nd.start();

  33.         }

  35. }
复制代码


5）sleep()方法和yield()方法的区别
A，        sleep()方法暂停当前线程后，会给其他线程执行的机会，不理会其他线程的优先级；
        yield()方法只会给优先级相同或者优先级更高的线程执行机会。
B,        sleep()方法会将线程转入阻塞状态，直到经过阻塞时间后，才会进入就绪状态；
        yield()方法将会让线程转入阻塞状态，强制进入就绪状态。
C,        sleep()方法声明抛出Interrupted Exception异常，调用sleep()方法时，要么捕捉该异常，要么显示声明抛出异常；
        yield()方法则没有声明抛出任何异常。
D，        sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。

6）改变线程优先级
A，线程默认的优先级都与创建它的父线程的优先级相同。
B，默认情况下，main线程具有普通优先级。
C，setPriority(int newPriority)设置线程的优先级；
   getPriority()返回指定线程的优先级
D，int newPriority范围1----10，MAX_PRIORITY:10;MIN_PRIORITY:1;NORM_PRIORITY:5;
E，代码示例
  1. package com.wayne.thread;

  3. public class MyPriorityThread extends Thread {
  4.        
  5.         public MyPriorityThread(String name) {
  6.                 // TODO Auto-generated constructor stub
  7.                 super(name);
  8.         }
  9.        
  10.         @Override
  11.         public void run() {
  12.                 // TODO Auto-generated method stub
  13.                 for(int i = 0;i<50;i++)
  14.                 {       
  15.                         System.out.println(getName()+",其优先级是"+getPriority()+",循环变量i="+i);
  16.                 }
  17.         }
  18.        
  19.         public static void main(String[] args)
  20.         {
  21.                 //将主线程main线程的优先级设置为6
  22.                 Thread.currentThread().setPriority(6);
  23.                
  24.                 for(int i = 0;i<30;i++)
  25.                 {
  26.                         MyPriorityThread myPriorityThreadHigh = new MyPriorityThread("HighPriorityThread");
  27.                         myPriorityThreadHigh.start();
  28.                         System.out.println(myPriorityThreadHigh.getName()+"创建之初优先级是"+myPriorityThreadHigh.getPriority());
  29.                         myPriorityThreadHigh.setPriority(Thread.MAX_PRIORITY);

  31.                        
  32.                         MyPriorityThread myPriorityThreadLow = new MyPriorityThread("LowPriorityThread");
  33.                         myPriorityThreadLow.start();
  34.                         System.out.println(myPriorityThreadLow.getName()+"创建之初优先级是"+myPriorityThreadLow.getPriority());
  35.                         myPriorityThreadLow.setPriority(Thread.MIN_PRIORITY);

  37.                 }
  38.         }
  39. }
复制代码
作者: 江江会回来的    时间: 2015-9-24 23:50
不错哦~



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2