多线程m2

1.什么是并发?什么是并行?

举例~

你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。

你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。

你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。

(你吃一会饭，再去打一会电话，然后再继续吃饭，如果速度足够快，就给人一种吃饭打电话同时进行的感觉，这个叫并行)

并发的关键是你有处理多个任务的能力，不一定要同时。

并行的关键是你有同时处理多个任务的能力。

所以我认为它们最关键的点就是：是否是『同时』。

2.并发与并行会造成什么影响?

 资源的争抢，死锁~
3.如何解决这些影响?

同一时间只能有一个线程来处理这个事，即使线程互斥，上锁lock ，可以管程->>>>>>最后聊到pv操作（原子操作），管程是通过pv操作来实现的~

4.简单描述一下ABA问题?

是什么（这个可以用一句话描述清楚）-> cas ->解决，加版本号

从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。

参考：
JUC原子类: CAS, Unsafe和原子类详解 | Java 全栈知识体系

1.有两个线程同时去修改一个变量的值，比如线程1、线程2，都更新变量值，将变量值从A更新成B。
⒉首先线程1、获取到CPU的时间片，线程2由于某些原因发生阻塞进行等待，此时线程1进行比较更新(CompareAndSwap)，成功将变量的值从A更新成B。
3.更新完毕之后，恰好又有线程3进来想要把变量的值从B更新成A，线程3进行比较更新
成功将变
量的值从B更新成A。
4.线程2获取到CPU的时间片，然后进行比较更新，发现值是预期的A，然后有更新成了B。但是线程1并不知道，该值已经有了
A->B->A这个过程，这也就是我们常说的ABA问题。
5.可以通过加版本号或者加时间戳解决，或者保证单向递增或者递减就不会存在此类问题。

5.实现一下DCL?
不会

6.实现一个阻塞队列(用Condition写生产者与消费者)?
不会

7.实现多个线程顺序打印abc?

class printABC{
    ReentrantLock lock = new ReentrantLock();
    Condition conditionA = lock.newCondition();
    Condition conditionB = lock.newCondition();
    Condition conditionC = lock.newCondition();
    volatile int value = 0;
    private int count ;
    public printABC(int count ) {
        this.count = count;
    }
    public void printABC() {
        new Thread(new ThreadA()).start();
        new Thread(new ThreadB()).start();
        new Thread(new ThreadC()).start();
    }

    class ThreadA implements Runnable {
        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < count; i++) {
                    while (value % 3!= 0) {
                        conditionA.await();
                    }
                    System.out.println("A");
                    conditionB.signal();
                    value++;
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            } finally  {
                lock.unlock();
            }
        }
    }

    class ThreadB implements Runnable {
        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < count; i++) {
                    while (value % 3!= 1) {
                        conditionB.await();
                    }
                    System.out.println("B");
                    conditionC.signal();
                    value++;
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            } finally  {
                lock.unlock();
            }
        }
    }

    class ThreadC implements Runnable {
        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < count; i++) {
                    while (value % 3!= 2) {
                        conditionC.await();
                    }
                    System.out.println("C");
                    conditionA.signal();
                    value++;
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            } finally  {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        printABC test = new printABC(1);
        test.printABC();
    }
}