多线程核心基础

1 进程和线程

​ 进程是OS分配资源的最进本的单位，线程是执行调度的最基本单位。分配资源最重要的是：独立的内存空间，线程调度执行（线程共享进程的内存空间，没有自己的独立空间）。
JVM线程与操作系统的线程是一一对应的，在JVM中启动一个线程，会交给操作系统启动一个线程。
纤程：用户太的线程，线程中的线程，切换和调度不需要经过OS。优势：占有资源很少，可以启动很多个（10W+）。目前支持向纤程的语言：GO、Python（lib）。Java目前不支持纤程。

2 实现多线程

//方法一：继承Thread
static class ThreadExtends extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ":T1");
        }
    }

//方法二：实现Runnable接口
static class ThreadImplRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + ":T2");
	}
}

// 方式3 实现Callble接口(线程执行带返回值的)
    class MyRun implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "success";
        }
    }
    @Test
    public void testCall(){
        MyRun t1 = new MyRun();
        try {
            String call = t1.call();
            System.out.println(call);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
//方式4 使用线程池创建（带返回值）
	public void threadPool(){
        ExecutorService pool = Executors.newCachedThreadPool();
        pool.execute(()->{
            System.out.println("hello ThreadPool");
        });
        Future<String> future = pool.submit(() -> {
            return "success";
        });
        try {
            //阻塞
            String msg = future.get();
            System.out.println(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
//方式5 使用FutureTask创建（带返回值）
    @Test
    public void testFutureTask(){
        FutureTask<String> task = new FutureTask<>(()->{
            return  "success";
        });
        new Thread(task).start();
        try {
            //阻塞
            String msg = task.get();
            System.out.println(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

3 启动线程

​ 线程启动使用start（）方法。为什么不能用run（）方法？start（）会启动新线程执行（不能重复start），run（）直接当前线程启动，不会使用新线程执行。

	//错误演示：使用run启动线程
	public static void main(String[] args) {
        ThreadExtends thread1 = new ThreadExtends();
        new Thread(thread1).run();
        System.out.println(Thread.currentThread().getName() + ":Main");
    }
//输出：
//	main:T1
//	main:Main
//结论：使用run()方法启动，执行线程为main线程，并非是thread1线程，并没有使用多线程执行

	//正确使用start()启动线程
	public static void main(String[] args) {
        ThreadExtends thread1 = new ThreadExtends();
        new Thread(thread1).start();
        System.out.println(Thread.currentThread().getName() + ":Main");
    }
//输出：
//	main:Main
//  Thread-1:T1
//结论：使用start方法启动线程，会开启多个线程执行，从而达到多线程执行的目的。

//jdk8使用Lambda表达式启动线程,实际也是通过实现Runnable接口
new Thread(()->{
	System.out.println(Thread.currentThread().getName() + ":T3");
}).start();

4 线程常用方法

4.1 Thread类中线程常用重要方法

• sheep()：sleep方法可以让线程进入waiting状态，并且不占用CPU资源，但是不释放锁，直到规定时间后再执行，休眠期间如果被中断，会爆出异常并清除中断状态。
• yield()：短暂让出CPU进入排队队列。
• join(): 因为其他线程加入了我们，所以我们要等他执行完了再出发。例：在A线程中执行B.join()即 让B线程执行完后再执行A线程。原理：自己进入waiting状态，加入的线程执行后自动notifyAll（）。

	@Test
    public void testJoin() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("T1执行");
            System.out.println("T1结束");
        });
        Thread t2 = new Thread(() -> {
            try {
                System.out.println("T2执行");
                t1.join();
                System.out.println("T2结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t3 = new Thread(() -> {
            try {
                System.out.println("T3执行");
                t2.join();
                System.out.println("T3结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t3.start();
        t1.start();
        t2.start();
        /**
         * 执行结果：
         * T3执行
         * T2执行
         * T1执行
         * T1结束
         * T2结束
         * T3结束
         * 结论：无论谁先抢到执行，都需要等T1执行结束后T2才能执行结束，最后T3执行结束。
         */
    }

4.2 Object类中线程常用重要方法

wait()，notify()， notifyAll()必须拥有monitor，属于Object类，和Condition类似。
notify唤醒：

• notify方法只应该被拥有该对象的monitor的线程调用；
• 一旦线程被唤醒，线程便会从对象的“等待线程集合”中被移除，所以可以重新参与到线程调度当中
• 要等刚才执行notify的线程退出被synchronized保护的代码并释放monitor
  wait等待以下情况之一才会被唤醒
• 另一个线程调用这个对象的notify()方法且刚好被唤醒的是本线程；
• 另一个线程调用这个对象的notifyAll()方法；
• 过了wait(long timeout)规定的超时时间，如果传入0就是永久等待；
• 线程自身调用了interrupt()

4.3 Condition中常用方法

Condition是个接口，基本的方法就是await()和signal()方法；Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()。调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用。Condition中的**await()对应Object的wait()；Condition中的signal()对应Object的notify()；Condition中的signalAll()**对应Object的notifyAll()。

/**
 * 实现一个固定容量同步容器,拥有put和get方法,以及getCount方法.
 * 能够支持2个生产者线程以及10个消费者线程的阻塞调用
 */
public class WaitAndNotilfy {
    List list = new ArrayList();
    //容器最大容量
    private final static int MAX = 10;
    private static int COUNT = 0;
    Lock lock = new ReentrantLock();
    //生产者
    Condition producer = lock.newCondition();
    //消费者
    Condition consumer = lock.newCondition();

    public Object get() {
        Object o = null;
        try {
            lock.lock();
            while (list.size() == 0) {
                System.err.println("消费者暂停");
                consumer.await();
            }
            o = list.get(0);
            list.remove(0);
            COUNT--;
            //通知生产者生产
            producer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return o;
    }

    public void put(Object o) {
        try {
            lock.lock();
            while (list.size() == MAX) {
                System.err.println("生产者暂停");
                producer.await();
            }
            list.add(o);
            ++COUNT;
            //通知生产者生成
            consumer.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return COUNT;
    }

    public static void main(String[] args) {
        WaitAndNotilfy c = new WaitAndNotilfy();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 5; j++) {
                    c.put(j);
                    System.out.println("生产者生产了:" + j + ",目前容量:" + c.getCount());
                }
            }).start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 5; j++) {
                    Object o = c.get();
                    System.out.println("消费者消费了:" + o + ",目前容量:" + c.getCount());
                }
            }).start();
        }
    }
}

5 线程6个状态

• new：刚创建线程还没有启动；
• Runnable：可运行；
• Blocked：被阻塞；
• Waiting：等待；
• Timed waiting：限期等待；
• Terminated：终止
  一般习惯而言，把Blocked(被阻塞）、Waiting(等待）、Timed_waiting(计时等待）都称为阻塞状态。
  

6 停止线程

通常情况下，我们不会手动停止一个线程，而是允许线程运行到结束，然后让它自然停止。但是依然会有许多特殊的情况需要我们提前停止线程，比如：用户突然关闭程序，或程序运行出错重启等。在这种情况下，即将停止的线程在很多业务场景下仍然很有价值。尤其是我们想写一个健壮性很好，能够安全应对各种场景的程序时，正确停止线程就显得格外重要。但是Java 并没有提供简单易用，能够直接安全停止线程的能力。

6.1 interrupt介绍

• interrupt() 设置线程打断标志位
• isInterrupted() 查询某线程是否被打断（查询表示位）
• static interrupted() 查询当前线程是否被打断过，并重置打断标志

    @Test
    public void testInterrupted() throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("Thread is interrupted!");
                    System.out.println(Thread.currentThread().isInterrupted());
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        t.interrupt();
    }
	/**
     * 输出:
     * 	Thread is interrupted!
     * 	true
	 * 结论：isInterrupted()查询不重置标志位
     */

	@Test
    public void testInterrupted2() throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){
                if(Thread.interrupted()){
                    System.out.println("Thread is interrupted!");
                    System.out.println(Thread.interrupted());
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        t.interrupt();
        //当前线程
        System.out.println("main:"+t.isInterrupted());
    }
    /**
     * 输出:
     *  main:false
     *  Thread is interrupted!
     *  false
     * 结论:Thread.interrupted() 会重置标志位
     */

注意：interrupted不能中断正在竞争锁的线程。如果允许打断，在线程加锁时Lock的lockInterruptibly()加锁，当interrupted对该线程设置标志位的时候，该线程会保InterruptedException异常。

6.2 使用interrupt停止线程

对于 Java 而言，最正确的停止线程的方式是使用 interrupt。但 interrupt 仅仅起到通知被停止线程的作用。而对于被停止的线程而言，它拥有完全的自主权，它既可以选择立即停止，也可以选择一段时间后停止，也可以选择压根不停止。

** 使用interrupt中断线程**
	@Test
    public void testInterruptNormal() throws InterruptedException {
        Thread t = new Thread(()->{
            while (!Thread.interrupted()){

            }
            System.out.println("t end");
        });
        t.start();
        Thread.sleep(500);
        t.interrupt();
    }

一旦调用某个线程的 interrupt() 之后，这个线程的中断标记位就会被设置成 true。每个线程都有这样的标记位，当线程执行时，应该定期检查这个标记位，如果标记位被设置成true，就说明有程序想终止该线程。

public class StopThread implements Runnable {
    @Override
    public void run() {
        int count = 0;
        while (!Thread.currentThread().isInterrupted() && count < 1000) {
            System.out.println(count++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();
        Thread.sleep(5);
        thread.interrupt();
    }
}
// 运行结果，输出没有到1000会被main线程中断
当线程处于sheep或await状态时，被其他线程interrupt，会报java.lang.InterruptedException
public class StopThread implements Runnable {

    @Override
    public void run() {
        int count = 0;
        try {
            while (!Thread.currentThread().isInterrupted() && count < 1000) {
                if(count==10){
                    Thread.sleep(10);
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();
        Thread.sleep(5);
        thread.interrupt();
    }
}
//运行结果：输出10个数后报异常

7获取子线程执行结果

查看Runnable接口可以发现，run()方法的返回是void，且未声明为抛出任何已检查的异常，而咱们实现并重写这个方法，自然也不能返回值，也不能抛出异常，因为在对应的Interface / Superclass中没有声明它。
Runnable为什么设计成这样？
如果run()方法可以返回值，或者可以抛出异常，也无济于事，因为我们并没办法在外层捕获并处理，这是因为调用run()方法的类（比如Thread类和线程池）也不是我们编写的。所以如果我们真的想达到这个目的，可以看看下面的补救措施：

1. 使用Callable，声明了抛出异常并且有返回值；

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

2. 用Future来获得子线程的运行结果；