JUC基础(一): 什么是JUC(JUC概述)

什么是JUC

JUC简介

在Java中,线程部分是一个重点,本篇文章说的JUC也是关于线程的. JUC就是java.util.concurrent工具包的简称. 这是一个处理线程的工具包, JDK1.5开始出现的.

进程和线程

• 进程(process)是计算机中的程序关于某数据集合三的一次运行或动, 是系统进行资源分配和调度的基本单位, 是操作系统接口的基础. 在当代面向线程设计的计算机结构中, 进程是线程的容器. 程序是指令, 数据及其组织形式的描述, 进程是程序的实体. 是计算机中的程序关于某数据集合上的一次运行活动, 是系统进行资源分配和调度的基本单位, 是操作系统结构的基础. 程序是指令, 数据及其组织形式的描述, 进程是程序的实体.
• 线程(thread)是操作系统能够进行运算的最小单位. 他被包含在进程之中, 是进程中的实际运作单位. 一条线程指的是进程中一个单一顺序的控制流, 一个进程中可以并发多个线程,每个线程并行执行不同的任务.

​ 总结来说:

• 进程: 指在系统中正在运行的一个应用程序; 程序一单运行就是进程; 程序一旦进行就是进程; 进程-----资源分配的最小单位.
• 线程: 系统分配处理器时间资源的基本单元, 或者说进程之内独立执行的一个单元执行流. 线程-----程序执行的最小单位

线程的状态

线程状态枚举类型

Thread.State

public enum State {
    /**
     * (新建)
     * Thread state for a thread which has not yet started.
     */
    NEW,

    /**
     * (准备就绪)
     * Thread state for a runnable thread. A thread in the runnable * state is 		executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,
    /**
     * (阻塞)
     * Thread state for a thread blocked waiting for a monitor lock. * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling * {@link Object#wait() Object.wait}.
     */
    BLOCKED,
    /**
     * (不见不散)
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     * <li>{@link Object#wait() Object.wait} with no timeout</li>
     * <li>{@link #join() Thread.join} with no timeout</li>
     * <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul> *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action. *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on * that object. A thread that has called <tt>Thread.join()</tt> * is waiting for a specified thread to terminate.
     */
    WAITING,
    /**
     * (过时不候)
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     * <li>{@link #sleep Thread.sleep}</li>
     * <li>{@link Object#wait(long) Object.wait} with timeout</li>
     * <li>{@link #join(long) Thread.join} with timeout</li>
     * <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li> * <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,
    /**
     * (终结)
     * Thread state for a terminated thread. * The thread has completed execution.
     */
    TERMINATED;
}

wait和sleep的区别

1. sleep是Thread的静态方法,wait是Object的方法,对任何对象实例都能调用
2. sleep不会释放锁,她也不需要占用锁.wait会释放锁,但调用他的前提是当前线程占有锁(即代码要在synchronized中).
3. 他们都会被interrupted方法中断,同时他们都有一个特性是在哪里睡就会在哪里醒

并行和串行

串行模式

串行表示所有任务都一一按照顺序进行,.串行意味着必须先装完一车柴火才能运送这车,只有运送到了,才能卸下这车柴火,并且只有完成了这整个三个步骤,才能进行下一个步骤.

串行是一次只能取得一个任务,并执行这个任务

并行模式

并行意味着可以同时取得多个任务,并同时去执行所取得的这些任务.并行模式相当于将长长的一条队列,划分成了多条短队列,所以并行缩短了任务队列的长度,并行的效率从代码层次上强依赖于多进程/多线程代码,从硬件角度上则依赖多核CPU.

并发

**并发(concurrent)指的是多个程序可以同时运行的现象,更细化的是多进程可以同时运行或者多指令可以同时运行.**但这不是重点, 在描述并发的时候不会去扣这种字眼是否精确,并发的重点在于它是一种现象,并发描述的是多进程同时运行的现象,但实际上,对于单核心CPU来说,同一时刻只能运行一个线程,所以这里的“同时运行”表示的不是真的同一时刻有多线程运行的现象,这是并行的概念,而是提供一种功能让用户看来多个程序同时运行起来了,但实际上这些程序中的进程不是一直霸占CPU的,而是自信一会儿停一会儿.

要解决大并发问题,通常是将大任务分解成多个小人物,由于操作系统对调度是随机的,所以切分成多个小任务后,可能回从任意小任务处执行,这可能回出现一些现象:

• 可能出现一个小任务执行了多次,还没开始下个任务的情况,这是一般会采用队列或者类似的数据就够来存放各个小任务的成果.
• 可能出现还没准备好第一步就执行第二步的可能,这是,一般采用多路复用或异步的方式,比如只有准备好产生了时间通知才执行某个任务.
• 可以多进程/多线程的方式并执行这些小人物,也可以单进程/线程执行这些个小人物,这时很可能要配合多路复用才能达到较高的效率.

小结

并发: 同一时刻多个线程在访问同一资源,多个线程对一点

​ 例子: 春运抢票 电商秒杀

并行: 多项工作一起执行,之后再汇总

​ 例子: 泡方便面 电水壶烧水 一边撕调料倒入桶中

管程

管程(monitor:监视器 > Java中所谓的锁)是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现),但是这样并不能保证进程以设计的顺序执行

JVM中同步是机遇进入和退出管程对象实现的,每一个对象都会有一个管程对象,管程会随着Java对象一同创建和销毁

执行线程首先要持有管程对象,然后才能执行方法,当方法完成之后会释放管程,方法在执行时候会持有管程,其他线程无法再获取同一个管程

用户线程和守护线程

用户线程: 平时用到的普通线程,自定义线程

守护线程: 运行在后台,是一种特殊的线程,比如垃圾回收

当主线程结束后,用户线程还在运行,JVM存活

如果没有用户线程,都是守护线程,JVM结束

例子: 如果我们不设置守护线程的情况

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 其中的isDaemon方法是用来判断是否是守护线程，如果返回的是false说明不是守护线程
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while (true) {
            }
        }, "t");
        t.start();

        System.out.println(Thread.currentThread().getName() + "::" + "over");
    }
}

/********************* 控制台信息 *************************/
Connected to the target VM, address: '127.0.0.1:50636', transport: 'socket'
main::over
t::false
// 同时程序并没有结束因为虽然主线程结束了但是,t线程还没结束

例子: 如果我们将线程t设置为守护线程

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 其中的isDaemon方法是用来判断是否是守护线程，如果返回的是false说明不是守护线程
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while (true) {
            }
        }, "t");
        // 设置守护线程
        t.setDaemon(true);
        t.start();
        System.out.println(Thread.currentThread().getName() + "::" + "over");
    }
}

/********************* 控制台信息 *************************/
Connected to the target VM, address: '127.0.0.1:50636', transport: 'socket'
main::over
t::true
Disconnected from the target VM, address: '127.0.0.1:50636', transport: 'socket'
// 程序结束因为除了守护线程之外没有其他运行的线程了