多线程——线程控制

join方法

Thread类中join方法主要作用就是同步，使线程之间的并发执行变为串行执行。

public class JoinTest {
	public static void main(String [] args) throws InterruptedException {
        ThreadJoin t1 = new ThreadJoin("aa");
        ThreadJoin t2 = new ThreadJoin("bb");
        t1.start();
        t1.join(10);
        t2.start();
	}
}
class ThreadJoin extends Thread{
	public ThreadJoin(String name){
		super(name);
	}
	@Override
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println(this.getName() + ":" + i);
		}
	}
}

在main主线程中调用了t1线程的join()方法时，表示只

有当t1线程执行完毕时，main主线程才能继续执行。

join参数表示main线程会等待t1线程10毫秒，10毫秒过后，join的功效结束，即串行执行恢复为并行执行。join(0)与join()相同。

join需要在start后调用。

守护线程

在后台运行的，为其他线程提供服务，(Daemon Thread)。JVM的垃圾回收就是典型的守护线程。

**特征：**守护线程服务对象线程都死亡后，守护线程也会自动死亡。

sleep方法

让当前线程休眠，sleep(long millis)、sleep(long millis, int nanos) 毫秒，纳秒。

**调用方式：**Thread.sleep(xx)

**调用位置：**线程run方法中

sleep方法只能让当前线程睡眠。调用某一个线程类的对象t.sleep()，睡眠的不是t，而是当前线程。

其他写法：

TimeUnit.SECONDS.sleep(1);
TimeUnit.MINUTES.sleep(1);
TimeUnit.HOURS.sleep(1);
TimeUnit.DAYS.sleep(1);

优先级

java 中的线程优先级的范围是1～10，1的优先级最低，10的优先级最高。

在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行，虽然说可以通过线程的优先权进行设置，但是他只是获取CUP执行权的概率高点，也不一定必须先执行 。

public class PriorityTest extends Thread {
    public PriorityTest(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(getName() + ",其优先级是："
                    + getPriority() + ",循环变量的值为:" + i);
        }
    }

    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.start();
                System.out.println("改低之前的优先级:"
                        + low.getPriority());
                // 设置该线程为最低优先级
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if (i == 20) {
                PriorityTest high = new PriorityTest("高");
                high.start();
                System.out.println("改高之前的优先级:"
                        + high.getPriority());
                // 设置该线程为最高优先级
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

线程让步

Thread中有一个线程让步方法yield()，作用就是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

public class YieldTest {

    public static void main(String[] args) {
        ThreadA t1 = new ThreadA("t1");
        ThreadA t2 = new ThreadA("t2");
        t1.start();
        t2.start();
    }

}

class ThreadA extends Thread {
    public ThreadA(String name) {
        super(name);
    }

    public synchronized void run() {
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i);
            if (i % 4 == 0) {
                Thread.yield();
            }
        }
    }
}