Java多线程（二）多线程常用方法

1.多线程的阻塞状态

　　join()（线程串行化）：如果在一个线程运行的过程中要用到另一个线程的运行结果，则可进行线程的串型化处理。一个线程调用了join()方法，必须等待另一个线程执行完毕后才能执行

package jsontest;


public class RunableDemo implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<10;i++){
            System.out.println("-----------"+Thread.currentThread().getName()+"----"+i);
        }
    }
    
    public static void main(String[] args) {
        RunableDemo d = new RunableDemo() ;
        Thread t = new Thread(d) ;
        int k = 0 ;
        for(;k<10;k++){
            System.out.println("---------"+Thread.currentThread().getName()+"----"+k);
            if(k==5){
                t.start();
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
结果：
---------main----0
---------main----1
---------main----2
---------main----3
---------main----4
---------main----5
-----------Thread-0----0
-----------Thread-0----1
-----------Thread-0----2
-----------Thread-0----3
-----------Thread-0----4
-----------Thread-0----5
-----------Thread-0----6
-----------Thread-0----7
-----------Thread-0----8
-----------Thread-0----9
---------main----6
---------main----7
---------main----8
---------main----9

2.sleep()：暂停执行当前运行中的线程，使之进入阻塞状态，待经过指定的”延迟时间’后再醒来并转入到就绪状态

package jsontest;


public class RunableDemo implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<10;i++){
            System.out.println("-----------"+Thread.currentThread().getName()+"----"+i);
        }
    }
    
    public static void main(String[] args) {
        RunableDemo d = new RunableDemo() ;
        Thread t = new Thread(d) ;
        int k = 0 ;
        for(;k<10;k++){
            System.out.println("---------"+Thread.currentThread().getName()+"----"+k);
            if(k==5){
                t.start();
                try {
                    Thread.sleep(5000);//thread线程执行完后，过5秒在执行main线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.后台线程（Daemon Thread）

　　目地：后台线程主要是为其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。

　　生命周期：后台线程的生命周期与前台线程生命周期有一定关联。主要体现在：当所有的前台线程都进入死亡状态时，后台线程会自动死亡(其实这个也很好理解，因为后台线程存在的目的在于为前台线程服务的，既然所有的前台线程都死亡了，那它自己还留着有什么用...伟大啊 ! !)。

　　设置后台线程：调用Thread对象的setDaemon(true)方法可以将指定的线程设置为后台线程。

package jsontest;


public class RunableDemo implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<1000;i++){
            System.out.println("-----------"+Thread.currentThread().getName()+"----"+i);
        }
    }
    
    public static void main(String[] args) {
        RunableDemo d = new RunableDemo() ;
        Thread t = new Thread(d) ;
        int k = 0 ;
        for(;k<10;k++){
            System.out.println("---------"+Thread.currentThread().getName()+"----"+k);
            if(k==5){
                t.setDaemon(true);//设置thread线程是后台线程，当前台main线程执行完毕后，后台线程也就跟着结束了
                t.start();
            }
        }
    }
}

　　判断线程是否是后台线程：调用thread对象的isDeamon()方法。

　　注：main线程默认是前台线程，前台线程创建中创建的子线程默认是前台线程，后台线程中创建的线程默认是后台线程。调用setDeamon(true)方法将前台线程设置为后台线程时，需要在start()方法调用之前。前天线程都死亡后，JVM通知后台线程死亡，但从接收指令到作出响应，需要一定的时间。

4.改变线程的优先级/setPriority()：

　　每个线程在执行时都具有一定的优先级，优先级高的线程具有较多的执行机会。每个线程默认的优先级都与创建它的线程的优先级相同。main线程默认具有普通优先级。　　

　　设置线程优先级：setPriority(int priorityLevel)。参数priorityLevel范围在1-10之间，常用的有如下三个静态常量值：

　　MAX_PRIORITY:10

　　MIN_PRIORITY:1

　　NORM_PRIORITY:5

　　获取线程优先级：getPriority()。

　　注：具有较高线程优先级的线程对象仅表示此线程具有较多的执行机会，而非优先执行　

package jsontest;


public class RunableDemo implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<100;i++){
            System.out.println("-----------"+Thread.currentThread().getName()+"----"+i);
        }
    }
    
    public static void main(String[] args) {
        RunableDemo d = new RunableDemo() ;
        Thread t = new Thread(d) ;
        int k = 0 ;
        for(;k<100;k++){
            System.out.println("---------"+Thread.currentThread().getName()+"----"+k);
            if(k==5){
                t.setPriority(Thread.MAX_PRIORITY);
                t.start();
            }
        }
    }
}

5.线程让步：yield()让运行中的线程主动放弃当前获得的CPU处理机会，但不是使该线程阻塞，而是使之转入就绪状态

　　yield()方法线程优先级有关，当某个线程调用yiled()方法后，把执行机会让给相同或者更高优先级的线程。　

package jsontest;


public class RunableDemo implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<100;i++){
            System.out.println("-----------线程1----"+i);
        }
    }
    
    public static void main(String[] args) {
        RunableDemo d = new RunableDemo() ;
        RunableDemo2 r = new RunableDemo2() ;
        Thread t = new Thread(d) ;
        Thread t2 = new Thread(r) ;
        t.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        int k = 0 ;
        for(;k<100;k++){
            System.out.println("---------"+Thread.currentThread().getName()+"----"+k);
            if(k==20){
                t.start();
                t2.start();
                Thread.yield();
            }
        }
    }
}

class RunableDemo2 implements Runnable {

    @Override
    public void run() {
        int i = 0 ;
        for(;i<100;i++){
            System.out.println("--------线程2----"+i);
        }
        
    }
    
}

参考：http://www.cnblogs.com/lwbqqyumidi/p/3817517.html