线程管理

树图

sleep()

public static void sleep(long millis)    throws InterruptedException

millis - 以毫秒为单位的睡眠时间长度

使用方法时包含在try-catch语句中
如果在同步方法或同步块中使用sleep()方法时，并不会让出CPU资源;
与此相对的是wait()方法，在同步方法或同步块使用该方法时，会让出CPU资源。直到有线程用notify()或notifyAll()唤醒进入就绪队列。

try {
            Thread.sleep(SleepTime);
        } catch (InterruptedException ex) {
            Logger.getLogger(WorkRun.class.getName()).log(Level.SEVERE, null, ex);
        }

join()

public final void join()
                throws InterruptedException

通过调用join()方法可以调节线程运行的先后顺序

实例

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author qaz22
 */
public class 线程控制 {
    public static void main(String[] args) {
        int number[]=new int[2];
        number[0]=0;
        number[1]=0;
        System.out.println("number[0]="+number[0]+";number[1]="+number[1]);
        Thread a=new Thread(new GetNumber(number));
        Thread b=new Thread(new WorkRun(number, a));
        Thread c=new Thread(new PrintRun(b, number));
        
        //第一种start调用先后
        a.start();
        b.start();
        c.start();
        
        /*
        第二种start调用先后
        c.start();
        b.start();
        a.start();
        */
        
        try {
            c.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(线程控制.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("主线程  number[0]="+number[0]+";number[1]="+number[1]);
    }
}

class GetNumber implements Runnable{
    int number[];

    public GetNumber(int[] number) {
        this.number = number;
    }
    
    @Override
    public void run() {
        System.out.println("GetNumber-1");
        number[0]=100;
        number[1]=200;
        System.out.println("number[0]="+number[0]+";number[1]="+number[1]);
        System.out.println("GetNumber-2");
    }
    
}

class WorkRun implements Runnable{
    int number[];
    Thread lastThread;

    public WorkRun(int[] number, Thread lastThread) {
        this.number = number;
        this.lastThread = lastThread;
    }
    
    
    @Override
    public void run() {
        System.out.println("WorkRun-1");//为证明join()控制线程的先后是在调用join方法后实现
        try {
            lastThread.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(WorkRun.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("WorkRun-2");
        number[0]=23;
        number[1]=32;
        System.out.println("number[0]="+number[0]+";number[1]="+number[1]);
        System.out.println("WorkRun-3");
    }
    
}

class PrintRun implements Runnable{
    Thread lasThread;
    int number[];

    public PrintRun(Thread lasThread, int[] number) {
        this.lasThread = lasThread;
        this.number = number;
    }
    
    @Override
    public void run() {
        System.out.println("PrintRun-1");//为证明join()控制线程的先后是在调用join方法后实现
        try {
            lasThread.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(PrintRun.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("PrintRun-2");
        System.out.println("number[0]="+number[0]+";number[1]="+number[1]);
        System.out.println("PrintRun-3");
    }
}

第一种start调用先后的运行截图
可知运行的先后按照预期进行，即线程运行的顺序为a->b->c

第二种start调用先后的运行截图
可知运行的先后在各个线程调用join()方法前有一定的出入