7.并发编程

超、凢脫俗 2023-07-03 15:28 13阅读 0赞

1.线程和进程的关系？

一个进程可以有多个线程，但必须有一个线程，一个线程只能在一个进程的范围内活动。

2.并发和并行的区别？

并发是指有公共资源的争夺，并行是没有公共资源的争夺。

3.实现多线程的方式？

1>.继承Thred类，重写run接口。

2>.实现Runnable接口，实现run方法。

3>.通过Callable接口，实现call方法。

4.什么是守护线程？

专门用于服务其他的线程,如果其他的线程(即用户自定义线程)都执行完毕,连main线程也执行完毕,那么jvm就会退出(即停止运行)——此时,连jvm都停止运行了,守护线程当然也就停止执行了

5. synchoried原理？

这个原本是个重量级锁，但是在后来更新中进行了优化，引入了偏向锁和轻量级锁。通过锁膨胀一步步升级为重量级锁。

以前的文章：[https://blog.csdn.net/huaixiaohai\_1/article/details/92607179][https_blog.csdn.net_huaixiaohai_1_article_details_92607179]

还是说原理吧：JVM基于进入和退出Monitor对象来实现同步和代码块同步，同步代码块是通过monitorenter和monitorexit实现的。同步方法是通过另一种方式实现的（JVM规范中并没有说明）。但是还是可以使用这种方法，monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit插入在结束或者异常的位置。必须对应。

6.volicate原理？

volicate主要是通过Lock前缀指令来实现的。

lock前缀指令会引起处理器缓存写回到内存中。当一个处理器的缓存写回到内存中会导致其他处理器的缓存无效。

还有一个作用是他会禁止指令重排序。

7.禁止指令重排序是什么原理？

通过内存屏障

8.原子类实现原理？

以AutomicInteger为例进行源码分析：

// setup to use Unsafe.compareAndSwapInt for updates
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
    
        private volatile int value;

上面这段代码的意思是：JVM可以实现Java对象的布局，也就是在内存里Java对象的各个部分放在哪里，包括对象的实例字段和一些元数据之类。jdk内部使用的工具类sun.misc.Unsafe提供的方法objectFieldOffset()用于获取某个字段相对Java对象的“起始地址”的偏移量，可以使用这个偏移量调用getInt、getLong、getObject等方法来获取某个Java对象的某个字段。  
还可以看到value通过volatile保证可见性：

//两个构造方法 
    public AtomicInteger(int initialValue) {
            value = initialValue;
        }
     public AtomicInteger() {
        }

//get和set方法
    public final int get() {
            return value;
        }
    
    public final void set(int newValue) {
            value = newValue;
        }

看一下关键方法：更新操作

public final int getAndUpdate(IntUnaryOperator updateFunction) {
            int prev, next;
            do {
                prev = get();
                next = updateFunction.applyAsInt(prev);
            } while (!compareAndSet(prev, next));
            return prev;
        }

public final boolean compareAndSet(int expect, int update) {
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }

他首先备份了一份原来的值，然后通过cas的方式一直while直到成功。

9. 信号量机制？

信号量机制是为了保护共享变量，使得一个线程只有一个时刻只有一个进程访问资源。

主要通过P（申请资源）V（释放资源）操作来实现信号量，对信号量的操作都是原子性的。

信号量S:用来记录资源数量，看是否能满足申请需要。

P(S) 若 S > 0:则S-1；线程继续执行，若S<0则挂起线程。

V(S) 若S>0;则S+1；若S<0，则唤醒一个线程。

10.AQS是什么，讲讲？

抽象的队列同步器，是除了java自带的synchronized关键字之外的锁机制。

如果请求的资源空闲，那么将当前请求资源设置为有效的工作线程，并将共享资源设置为锁定状态。如果请求的资源锁定，那么就进入CLH阻塞队列。

CLH阻塞队列：是一个虚拟双向队列，不存在实际的队列，仅记录节点之间的关联关系。

实际上AQS就是基于CLH队列，用volicate修饰共享变量state，线符程通过CAS去修改状态符。成功则获取锁成功，失败则进入等待队列。![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211bGluc2VuNzc_size_16_color_FFFFFF_t_70]

看这个图就清除多了。

11.为什么要用线程池？

当并发数量多的时候，频繁的创建和销毁线程费时间，所以采用线程池，让每个线程可以多次使用，减少消耗。

12.线程池的种类以及自定义线程池？

java提供了构建线程池，使线程池使用变得简单起来了。

public ThreadPoolExecutor(
                                  //初始线程数
                                  int corePoolSize,
                                  //最大线程个数
                                  int maximumPoolSize,
                                  //生存时间，超过初始线程个数以后的线程池使用后的销毁时间
                                  long keepAliveTime,
                                  //时间单位
                                  TimeUnit unit,
                                  //队列内部的使用数据结构
                                  BlockingQueue<Runnable> workQueue)

1>.单线程池(newSingleThreadExecutor)

public static ExecutorService newSingleThreadExecutor() {
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }

这个线程池可以清楚的看到初始线和最大线程都只有1个线程。

2>.定长线程池(newFixedThreadPool)

public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

可以看到最大和初始化的线程数一样。适合任务量比较固定且时间消耗比较长的

3>.可缓存线程池(newCachedThreadPool)

public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
        }

这个线程数量基本可以无限加，但是没用后60s之后就消失了。比较以用于任务量大但是消耗时间比较小的。

4>.大小无限制的线程池(newScheduledThreadPool)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
        }

这个线程池也时固定大小的，构造方法里边指定，最大线程数也是无限加，非核心线程创建完以后就销毁。但是这个线程池使用的DelayedWorkQueue，意味着他会把任务排序，执行完以后循环。适用于定时任务和固定周期的任务。

自定义线程池根据业务需求使用ThreadPoolExecutor去创建，

这些可能也不全，而且理解也不够透彻，并发编程的水太深了。

[https_blog.csdn.net_huaixiaohai_1_article_details_92607179]: https://blog.csdn.net/huaixiaohai_1/article/details/92607179
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211bGluc2VuNzc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20181128142923147.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211bGluc2VuNzc=,size_16,color_FFFFFF,t_70