JUC学习历程总结

为什么要有JUC

从两方面讲

1. 硬件方面
   摩尔失效
   它是由英特尔创始人之一Gordon Moore(戈登·摩尔)提出来的。其内容为：
   当价格不变时，集成电路上可容纳的元器件的数目约每隔18-24个月便会增加一倍，性能也将提升一倍。
   换言之，每一美元所能买到的电脑性能，将每隔18-24个月翻一倍以上。这一定律揭示了信息技术进步的速度。
   可是从2003年开始CPU主频已经不再翻倍，而是采用多核而不是更快的主频。
   摩尔定律失效。
   在主频不再提高且核数在不断增加的情况下，要想让程序更快就要用到并行或并发编程。
2. 软件方面
   高并发系统，异步+回调等生产需求

说线程先从start开始

其实Java语言本身的底层就是c++，当我们调用线程的start()方法是，
观看源码其实就是调用的是start0，也就是private native void start0();
更直观的看可以是线程中调用start方法，就是通过jvm调操作系统实现的。

java多线程的相关概念

进程

是程序的⼀次执⾏，是系统进⾏资源分配和调度的独⽴单位，每⼀个进程都有它⾃⼰的内存空间和系统资源

线程

在同⼀个进程内⼜可以执⾏多个任务，⽽这每⼀个任务我们就可以看做是⼀个线程，并且一个进程可以有一个或多个线程

管程

所谓的管程，就是监视器（Monitor）也就是我们平时所说的锁，它其实是一种同步机制，他的义务是保证（同一时间）只有一个线程可以访问被保护的数据和代码。JVM中同步是基于进入和退出监视器对象(Monitor,管程对象)来实现的，每个对象实例都会有一个Monitor对象，Monitor对象会和Java对象一同创建并销毁，它底层是由C++语言来实现的

用户线程和守护线程

Java线程分为用户线程和守护线程，
线程的daemon属性为true表示是守护线程，false表示是用户线程

public class ThreadDemo
{
public static void main(String[] args)
{
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName()+"\t 开始运行，"+(Thread.currentThread().isDaemon() ? "守护线程":"用户线程"));
while (true) {

        }
    }, "t1");
//线程的daemon属性为true表示是守护线程，false表示是用户线程
t1.setDaemon(true);
    t1.start();
//3秒钟后主线程再运行
try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

    System.out.println("----------main线程运行完毕");
}

}

守护线程 是一种特殊的线程，在后台默默地完成一些系统性的服务，比如垃圾回收线程
用户线程 是系统的工作线程，它会完成这个程序需要完成的业务操作
注意： 当程序中所有用户线程执行完毕之后，不管守护线程是否结束，系统都会自动退出，如果用户线程全部结束了，意味着程序需要完成的业务操作已经结束了，系统可以退出了。所以当系统只剩下守护进程的时候，java虚拟机会自动退出，并且设置守护线程，需要在start()方法之前进行

CompletableFuture

Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。
Callable接口中定义了需要有返回的任务需要实现的方法。
比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后，主线程就去做其他事情了，过了一会才去获取子任务的执行结果。

public void text() throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 20, 1L,
                TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(50), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "come in");
        });

        CompletableFuture<Void> voidCompletableFuture1 = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "come in");
        }, threadPoolExecutor);
        
        System.out.println(voidCompletableFuture.get());
        System.out.println(voidCompletableFuture1.get());
        
        CompletableFuture<Object> objectCompletableFuture = CompletableFuture.supplyAsync(() -> {
            return 147;
        });

        CompletableFuture<Integer> objectCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
            return 123;
        }, threadPoolExecutor);

        System.out.println(objectCompletableFuture.get());
        System.out.println(objectCompletableFuture1.get());
        threadPoolExecutor.shutdown();
    }