关于java:你知道什么是JUC了嘛

多线程始终 Java 开发中的难点，也是面试中的常客，趁着还有工夫，打算坚固一下 JUC 方面常识，我想机会随处可见，但始终都是留给有筹备的人的，心愿咱们都能加油！！！

沉下去，再浮上来，我想咱们会变的不一样的。

一、JUC 简介

JUC 实际上就是咱们对于 jdk 中java.util .concurrent 工具包的简称。这个包下都是 Java 解决线程相干的类，自 jdk1.5 后呈现。

二、过程与线程

2.1、过程

概述：

过程 （Process）是计算机中的程序对于某数据汇合上的一次运行流动，是 零碎进行资源分配和调度的根本单位 ，是 操作系统构造的根底 。在当代面向线程设计的计算机构造中， 过程是线程的容器 。 程序是指令、数据及其组织模式的 形容 ， 过程是程序的实体。

定义：

广义定义：过程是正在运行的程序的实例（an instance of a computer program that is being executed）。

狭义定义：过程是一个具备肯定独立性能的程序对于某个数据汇合的一次运行流动。它是操作系统动静执行的根本单元，在传统的操作系统中，过程既是根本的调配单元，也是根本的执行单元。

2.2、线程

线程（thread）是操作系统可能进行运算调度的最小单位。它被蕴含在过程之 中，是过程中的理论运作单位。一条线程指的是过程中一个繁多程序的控制流，一个过程中能够并发多个线程，每条线程并行执行不同的工作。

1、线程是独立调度和分派的根本单位。2、同一过程中的多条线程将共享该过程中的全副系统资源。3、一个过程能够有很多线程，每条线程并行执行不同的工作。可并发执行。

当然，咱们 Java 都晓得的线程的同步是 Java 多线程编程的难点，因为要给哪些地方是共享资源（竞争资源），什么时候要思考同步等，都是编程中的难点。😭所以才有了那么多滴锁，看到烦人。

2.3、创立线程的三种常见形式

1. 通过 实现 Runnable 接口来创立 Thread 线程

public class TheardCreateDemo {public static void main(String[] args) {Runnable runnable = new SomeRunnable();
        Thread thread1 = new Thread(runnable);
        thread1.start();
        //lamda 表达式形式
        Thread thread2 = new Thread(() -> {System.out.println("应用 lamda 表达式形式");
        });
        thread2.start();}
}
class SomeRunnable implements Runnable
{
    @Override
    public void run()
    {System.out.println(Thread.currentThread().getName()+":: 通过实现 Runnable 接口来创立 Thread 线程");
    }
}

2. 通过 继承 Thread 类来创立一个线程

public class TheardCreateDemo {public static void main(String[] args) {SomeThread thread = new SomeThread();
        thread.start();}
}

class SomeThread extends Thread{
    @Override
    public void run() {System.out.println("通过继承 Thread 类来创立一个线程");
    }
}

3. 通过 实现 Callable 接口来创立 Thread 线程

public class TheardCreateDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask<Object> futureTask = new FutureTask<Object>(new SomeCallable<Object>());
        Thread oneThread = new Thread(futureTask);
        
        oneThread.start();
        // 这里能够在运行之后取得 返回值
        System.out.println(futureTask.get());
    }
}

class SomeCallable<Object> implements Callable<Object> {
    @Override
    public Object call() throws Exception {System.out.println("通过实现 Callable 接口来创立 Thread 线程");
        // 这个是能够返回数据的 这里就轻易返回个 1024 哈
        return (Object)"这个是能够返回数据的 这里就轻易返回个哈";
    }
}

这里之后有篇文章还会讲到这个点的。

这里略微讲下步骤：

}
步骤 1：创立实现 Callable 接口的类 SomeCallable<Integer>

步骤 2：创立一个类对象：Callable<Integer> oneCallable = new SomeCallable<Integer>();

步骤 3：由 Callable<Integer> 创立一个 FutureTask<Integer> 对象：

FutureTask<Integer> futureTask= new FutureTask<Integer>(oneCallable);
正文：FutureTask<Integer> 是一个包装器，它通过承受 Callable<Integer> 来创立，它同时实现了 Future 和 Runnable 接口。

步骤 4：由 FutureTask<Integer> 创立一个 Thread 对象：Thread oneThread = new Thread(futureTask);

步骤 5：启动线程：oneThread.start();

这里为什么 Thread(FutureTask futureTask) 能够勒？

Thread 的构造函数：

public Thread(Runnable target) {this(null, target, "Thread-" + nextThreadNum(), 0);
}

起因：因为套娃套到一起啦。😁

public class FutureTask<V> implements RunnableFuture<V> 
    
public interface RunnableFuture<V> extends Runnable, Future<V> 

线程池的创立形式之后有一章会讲到，就不在此处减少篇幅啦。

三、并发和并行

在理解并发和并行之前，让咱们先来看一看串行是什么样的吧。

1）串行模式：

串行模式：即示意所有工作都是按先后顺序进行。串行是一次只能取的一个工作，并执行这个工作。

举个生存中的小例子：就是在火车站买票，明天只凋谢这一个窗口卖票，那么咱们只有等到后面的人都买了，能力轮到咱们去买。即按先后顺序买到票。

2）并行模式：

概述：一组程序按独立异步的速度执行，无论从宏观还是宏观，程序都是一起执行的。比照地，并发是指: 在同一个时间段内，两个或多个程序执行，有工夫上的重叠(宏观上是同时, 宏观上仍是程序执行)。

并行模式：并行意味着能够同时获得多个工作，并同时去执行所获得的这些工作。

咱们还是用下面那个例子：还是在买票，以前是只有一个窗口卖票，然而近几年倒退起来了，当初有五个窗口卖票啦，大大缩短了人们买票的工夫。

并行模式相当于将长长的一条队列，划分成了多条短队列，所以并行缩短了工作队列的长度。不过并行的效率，一方面受多过程 / 线程编码的好坏的影响，另一方面也受硬件角度上的 CPU 的影响。

3）并发：

并发 ： 并发指的是多个程序能够同时运行的一种景象 ，并发的重点在于它是一种景象, 并发形容的是多过程同时运行的景象。但真正意义上，一个单核心 CPU 任一时刻都只能运行一个线程。所以此处的 ” 同时运行 ” 示意的不是真的同一时刻有多个线程运行的景象（这是并行的概念），而是提供了一种性能让用户看来多个程序同时运行起来了，但实际上这些程序中的过程不是始终霸占 CPU 的，而是依据 CPU 的调度，执行一会儿停一会儿。

4）小小的总结一下：

并发：即同一时刻多个线程在拜访同一个资源，多个线程对一个点

• 例子：秒杀流动、12306 抢回家的票啦、抢演唱会的票 …

并行：多个工作一起执行，之后再汇总

• 例子：电饭煲煮饭、用锅炒菜，两个事件一起进行，(最初咱们一起干饭啦干饭啦😁)

四、用户线程和守护线程

用户线程：指不须要内核反对而在用户程序中实现的线程，其不依赖于操作系统外围，利用过程利用线程库提供创立、同步、调度和治理线程的函数来管制用户线程。

守护线程 ： 是指在程序运行的时候在后盾提供一种通用服务的线程，用来服务于用户线程；不须要下层逻辑染指，当然咱们也能够手动创立一个守护线程。(用文言来说：就是守护着用户线程，当用户线程死亡，守护线程也会随之死亡)

比方垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的局部。因而，当所有的非守护线程完结时，程序也就终止了，同时会杀死过程中的所有守护线程。反过来说，只有任何非守护线程还在运行，程序就不会终止。

用一个简略代码来模仿一下：

未设置为守护线程时：主线程执行实现了，然而咱们本人创立的线程依然未完结。

设置为守护线程后：显著能够看到，当主线程执行实现后，咱们设置为守护线程的那个线程也被强制完结了。

setDaemon就是设置为是否为守护线程。

五、喃喃自语

最近又开始了 JUC 的学习，感觉 Java 内容真的很多，然而为了可能走的更远，还是感觉应该须要打牢一下根底。

最近在继续更新中，如果你感觉对你有所帮忙，也感兴趣的话，关注我吧，让咱们一起学习，一起探讨吧。

你好，我是博主 宁在春，Java 学习路上的一颗小小的种子，也心愿有一天能扎根长成苍天大树。

心愿 与君共勉😁

待咱们，别时相见时，都已有所成。