Java多线程（2）

Java多线程（2）

1. 线程调度和线程控制

程序中的多个线程是并发执行的，某个线程若想被执行必须要得到cpu的使用权，Java虚拟机会按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制被称作线程的调度。

1.1线程调度

1.1.1 线程的两种调度模型

- 分时调度模型：所有线程轮流使用cpu，平均分配每个线程的cpu时间片(时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间)。
- 抢占式调度模型：：优先让优先级高的线程使用 CPU，如果线程的优先级相同，就会会随机选择一个。优先级高的线程获取的 CPU 时间片相对多一些。Java使用的是抢占式调度。

1.1.2 线程的优先级

线程的优先级用1-10的整数来表示，越大优先级越高，获得cpu时间片的机会越大（仅仅表示几率，次数较多时才能得到较好的结果）。

public class MyThread5 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("优先级:"+Thread.currentThread().getPriority()+">>>>"+Thread.currentThread().getName()+"---------正在执行第"+i+"次");
        }
    }
}
class TestMyThread5{
    public static void main(String[] args) {
        Thread t1=new Thread(new MyThread5(),"优先级高");
        Thread t2=new Thread(new MyThread5(),"优先级低");
        t1.setPriority(10);
        t2.setPriority(1);
        t2.start();
        t1.start();
    }
}

• public final int getPriority(); //获取线程的优先级

• public final void setPriority(int newPriority); //设置线程的优先级

• public final static int MIN_PRIORITY = 1;//最低优先级

• public final static int NORM_PRIORITY = 5;//普通优先级（线程的优先级默认为5）

• public final static int MAX_PRIORITY = 10;//最高优先级

1.2 线程控制

1.2.1线程控制的方法

方法	描述
sleep()	线程休眠，Thread类中的静态方法,会使线程转入阻塞状态,时间到了之后才会转入就绪状态，抛出InterruptedException异常
join()	线程加入，等待目标线程执行完后再继续执行，调用该方法的线程会插入优先先执行
yield()	线程礼让，暂停正在执行的线程，并执行其他线程，当线程执行了yield()方法，将转到就绪状态。
setDaemon()	将该线程标记为守护线程（后台线程）或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用
stop()	让线程停止，已过时
interrupt()	中断线程。 把线程的状态终止，并抛出一个InterruptedException

1.2.2 sleep()

线程休眠，使当前的线程暂停一段时间。进入休眠状态，其他的线程可以得到执行的机会。

public class MyThread6  {
    public static void main(String[] args) {
        DateTimeFormatter fmTime = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        for (int i = 0; i < 60; i++) {
            System.out.println("当前时间:"+LocalDateTime.now().format(fmTime));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

1.2.3 join()

线程加入，等待目标线程执行完之后再继续执行。阻塞当前调用join函数时所在的线程，直到接收函数执行完毕后再继续执行。官方注释：Waits for this thread to die.

public class MyThread7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1执行");
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 15; i++) {
                if(i==2){
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程2执行第"+i+"次");
            }
        });
        t2.start();
        t2.join();
        System.out.println("main线程执行完毕");
    }
}
执行结果：
线程2执行第0次
线程2执行第1次
线程1执行
线程2执行第2次
线程2执行第3次
线程2执行第4次
线程2执行第5次
线程2执行第6次
线程2执行第7次
线程2执行第8次
线程2执行第9次
线程2执行第10次
线程2执行第11次
线程2执行第12次
线程2执行第13次
线程2执行第14次
main线程执行完毕

1.2.4 yield()

线程让步，使线程从运行状态转换为就绪状态，即将cpu资源让给其他线程。当某个线程调用yield()方法之后，只有与当前线程优先级相同或者更高的线程才能获得执行的机会,执行yield()方法后该线程很快又有机会得到时间片。

public class MyThread8 {
    public static void main(String[] args) {
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1开始执行");
                try {
                    Thread.sleep(2);
                    System.out.println("线程1执行完毕");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });
        t1.start();
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2开始执行");
                while (!Thread.State.TERMINATED.equals(t1.getState())){
                    t1.yield();
                    System.out.println("等待线程1执行完毕");
                }
                System.out.println("线程2执行完毕");
            }
        });
        t2.start();
    }
}
执行结果：
线程2开始执行
线程1开始执行
等待线程1执行完毕
等待线程1执行完毕
等待线程1执行完毕
等待线程1执行完毕
等待线程1执行完毕
等待线程1执行完毕
等待线程1执行完毕
线程1执行完毕
等待线程1执行完毕
线程2执行完毕