作为后端开发，多线程是必经之路，个人觉得开发是靠自己感悟的玄学，刚入行时候对多线程的理解 和 目前对多线程的理解，完全是两个概念。（手动惊呆😮）

多线程最基本的可以自己先有个类继承Thread，或者实现Runable类，又或者实现Callable类。记得第一年找工作的时候，都会有人问，如果是你开发会选择继承还是实现，于是便回，选择实现，因为扩展性比继承更好。前面两个都是用start()启动，后面的有返回值，有FatureTask启动多线程。

后来知道了可以用Executors线程池来实现，线程池是jdk1.5之后引入的，传统的方法自己每次创建和销毁线程都会造成cpu资源的浪费，线程池可以统一的管理，来创建和销毁线程，大大增加业务逻辑运行内存的占比，而且复用核心线程，让空闲线程运行业务逻辑。

说到多线程就必须说到锁，在高并发的情况下，锁的使用，ReenTrantlock和synchronized，synchronized不需要自己手动释放锁，相对于必须在finally里必须手动释放锁来说更方便。他们都是可重入锁，并且都是通过线程阻塞来上锁的。

synchronize实例:

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

    static class ThreadA implements Runnable {

        @Override
        public void run() {
            synchronized (this) {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i + "线程名称：" + Thread.currentThread().getName());
                }
            }
        }
    }

ReenTrantLock实例：

private ReentrantLock reentrantLock = new ReentrantLock();

    public void two() {
        boolean f = reentrantLock.tryLock();
        try {
            System.out.println("tryLock:" + f);
        } finally {
            if (f) {
                reentrantLock.unlock();
            }
        }
    }

    public void one() throws InterruptedException {
        boolean f = false;
        try {
            if (f = reentrantLock.tryLock(2, TimeUnit.SECONDS)) {
                System.out.println("tryLock(2,TimeUnit.SECONDS):" + f);
            }
        } finally {
            if (f) {
                reentrantLock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // reentrantLock.lock();会等待其他线程 锁释放
        // reentrantLock.tryLock()若没有获取到锁，直接返回false。（一般都运用在防止重复点击）
        // reentrantLock.tryLock(5, TimeUnit.SECONDS) 等待一段时间，若没有获取 则返回false
       //  reentrantLock.lockInterruptibly();可中断锁
        final ReentrantLockController al = new ReentrantLockController();
        al.one(); // True -- 可以成功获得锁
        al.two(); // True --可以成功获得锁
        //新创建一个线程获得锁并且不释放
        new Thread() {
            {
                setDaemon(true);
            }

            @Override
            public void run() {
                al.reentrantLock.lock();
                System.out.println("acquired");
            }
        }.start();
        Thread.sleep(100);// 保证新线程能够先执行
        al.one(); // False -- 马上中断放弃
        al.two(); // False -- 等两秒超时后中断放弃

    }