Java基础之线程阻塞

    线程总是存在优先级，优先级范围在1~10之间，线程默认优先级是5； JVM线程调度程序是基于优先级的抢先调度机制； 在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级

package unit_fifteen;

public class TestPriority {

    public static void main(String[] args) {
        Thread tone = new ThreadOne();
        // 线程的默认优先级为5，这里设置为10
        tone.setPriority(10);
        // 获取tone的优先级
        System.out.println(tone.getPriority());
        // 当前线程为Main()主线程
        System.out.println(Thread.currentThread().getName());
        tone.start();
        Thread ttwo = new ThreadTwo();
        ttwo.start();

    }

}

class ThreadOne extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("我是第" + i + "个阿三!");
            System.out.println(Thread.currentThread().getName() + i);
        }
    }

}

class ThreadTwo extends Thread {

    @Override
    public void run() {
        for (int j = 0; j < 5; j++) {
            System.out.println("我是第" + j + "个李四!");
        }
    }

}

    注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作

    Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态；sleep()是静态方法，只能控制当前正在运行的线程

 

package unit_fifteen;

public class MyThread extends Thread {

    public void run() {
        for (int i = 0; i <=20; i++) {
            if ((i) % 10 == 0) {
                System.out.println("-------" + i);
            } 
            System.out.print(i);
            try {
                //睡眠1秒
                Thread.sleep(1000); 
                System.out.print("线程睡眠1秒！\n");
            } catch (InterruptedException e) {
                e.printStackTrace(); 
            } 
        } 
    } 

    public static void main(String[] args) {
        new MyThread().start();
    } 
}

 

    Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中

    Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作

package unit_fifteen;

public class MyThread {

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new ThreadOneDemo().start();
            if (i == 3) {
                try {
                    // 调用join()方法
                    Thread t = new ThreadTwoDemo();
                    t.start();
                    t.join();
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadOneDemo extends Thread {
    public void run() {
        System.out.println("我正在运行!");
    }
}

class ThreadTwoDemo extends Thread {
    public void run() {
        for (int j = 0; j < 5; j++) {
            System.out.println("我是新加入者!");
        }
    }
}