（七）线程的优先级Priority和关键词：synchronized

线程执行顺序，其实就是看谁先争夺到资源，那么有没有办法改变这种机制呢？
答案是，有的，但是也只是干预，并不是说不让他们去争夺资源。
那就是使用了：线程优先级

同时我们也简单了解一下 synchronized 这个关键词，了解一下他的特性和简单用法等。

package com.zmkj.admin.test;

import lombok.SneakyThrows;

/**
 * 线程优先级
 *
 * 温习一下线程的几种状态：
 * 新建(NEW)、可运行(RUNNABLE)、运行(RUNNING)、阻塞(BLOCKED)、死亡(DEAD)
 * 线程在：可运行 这个状态的时候，其实是在等CPU的资源，这个时候不考虑设置了其他的因素，我们可以认为每个线程是公平竞争资源的，谁争到谁运行。
 *
 * 这个其他因素 最直接的就是 "线程优先级"，但是只是说优先级高的，在竞争的时候有资源，但也只是有可能，这是个概率问题。
 * 但是这里也需要面对另外一个问题"饥饿问题"：优先级低的一直无法获得资源，一直无法运行，最终"饿死了"。
 *
 *
 * 关键词：synchronized
 * synchronized 的作用是实现线程间的同步。
 * 他的工作是对同步的代码加锁，是的每次，只能有一个线程进入同步块，从而保证线程间的安全性。
 *
 * 具体下面讲哈
 *
 * @author sunminghao
 */
public class PriorityDemoAndSynchronized {

    public static class HightPriority extends Thread{
        static int count = 0;

        @SneakyThrows
        @Override
        public void run() {
            while (true){
                synchronized (PriorityDemoAndSynchronized.class){
                    count++;
                    if (count > 10000000){
                        System.out.println("HightPriority is complete.");
                        break;
                    }
                }
            }
        }
    }

    public static class LowPriority extends Thread{
        static int count = 0;

        @SneakyThrows
        @Override
        public void run() {
            while (true){
                synchronized (LowPriority.class){
                    count++;
                    if (count > 10000000){
                        System.out.println("LowPriority is complete.");
                        break;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread high = new HightPriority();
        LowPriority low = new LowPriority();
        high.setPriority(Thread.MAX_PRIORITY);
        low.setPriority(Thread.MIN_PRIORITY);
        low.start();
        high.start();
    }

    /**
     * 在Java 中，使用1 到 10 表示线程的优先级，一般的可使用内置的三个静态标量表示。
     * 数字越大，优先级越高。
     */
    public final static int MIN_PRIORITY = 1;
    public final static int NORM_PRIORITY = 5;
    public final static int MAX_PRIORITY = 10;

    /**
     *
     * 上面的栗子中，分别将两个线程设置了不同的两个优先级，执行内容相同，都是在count 累加到10000000 时，打印出提示语。（这个数值一定要大，不然效果不明显）
     *
     * 注意，在对count 累加前，我们使用了synchronized 产生了一次资源竞争，目的是使得优先级的差异表现得更加明显。
     *
     * 大多数情况下，会优先输出 "HightPriority is complete."  但是记住了 这个也不是绝对的！！！
     */


    /**
     * synchronized 关键词
     * 简单的说就是，保证 线程 A 在写入时，线程B 不仅不能写，同时也不能读。
     *
     * 之前我们的例子里面有用到 volatile 关键词，
     * volatile 虽然确保了一个线程修改了数据后，其他线程能够看到这个改动，但是 他也只是改善了线程的错误率，但并不是解决。
     * 在多线程方面，存在资源竞争的现象，当 A 线程 读取到了 一个数据 count 值后，进行了加 1 操作，但是在 A 读取的同时，
     * B线程也读取到了 count = 1， 之后进行了加 2 ，那么，你说最后 count 是应该等于几呢？
     * 等于 2 吗？ 等于 3 吗？ 等于 5 吗？
     * 其实正确的结果是不是应该 是  1 + 1 + 2 = 4
     * 怎么做到呢？就需要 synchronized 保证了
     *
     * 他保证了 ----  线程安全
     * 多种用法这里做一下简单的整理：
     *
     * 1、指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。
     * 2、直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例对锁。
     * 3、直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。
     *
     * TODO synchronized除了用于线程同步、确保线程安全外，还可以保证线程间的 可见性 和 有序性。
     */
}