JAVA JUC的整理

最新推荐文章于 2024-09-12 21:20:12 发布

瘾855

最新推荐文章于 2024-09-12 21:20:12 发布

阅读量359

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_64126328/article/details/122810932

版权

本文探讨了Java中volatile关键字的内存可见性，以及CAS算法确保的原子性。还介绍了 ConcurrentHashMap 锁分段、CountDownLatch 闭锁、Callable接口、Lock同步锁和Condition控制等并发工具。涵盖了线程调度、ForkJoinPool工作窃取等高级主题。

摘要由CSDN通过智能技术生成

1.JAVA JUC简介

2.volatile关键字-内存可见性（比同步锁快）

/**

* 一、volatile 关键字: 当多个线程进行操作共享数据时，可以保证内存中的数据可见。

*      相较于synchronizd是一种较为轻量级的同步策略。

* 注意：

* 1.volatile 不具备“互斥性”

* 2.volatile 不能保证变量的：原子性“

*

*/

public class TestVolatile {

    public static void main(String[] args) {

        ThreadDemo td=new ThreadDemo();

        new Thread(td).start();

      /*  while (true) {

            synchronized (td) {

                if (td.isFlag()) {

                    System.out.println("-------");

                    break;

                }

            }

        }*/

        while (true) {

                if (td.isFlag()) {

                    System.out.println("-------");

                    break;

                }

            }

    }

}

class ThreadDemo implements Runnable {

    private volatile boolean flag = false;

    //private boolean flag = false;

    @Override

    public void run() {

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

        }

        flag = true;

        System.out.println("flag="+ isFlag());

    }

    public boolean isFlag() {

        return flag;

    }

    public void setFlag(boolean flag) {

        this.flag = flag;

    }

}

//输出结果为：-------

            flag=true

3.原子变量-CAS算法

/**

* 一、i++原子性问题：i++的操作实际上分为三个步骤”读-改-写“

*      int i = 10;

*      i = i++;//10

*      int temp =i;

*      i =I +1;

*      i = temp;

* 二、原子变量：jdk1.5a后Java。util.concurrent.atomic包下提供了常用的原子变量：

*      1.volatile保证内存可见性

*      2.CAS（Compare-And-Swap）算法保证数据的原子性

*          CAS算法是硬件对于并发操作共享数据的支持

*          CAS包含了三个操作数：

*          内存值V

*          预估值A

*          更新值B

*          当且仅当V==A时，V=B。否则，将不做任何操作

*/

public class TestAtomicDemo {

    public static void main(String[] args) {

        AtomicDemo ad = new AtomicDemo();

        for (int  i = 0; i < 10;i++) {

            new Thread(ad).start();

        }

    }

}

class AtomicDemo implements Runnable {

    //private volatile int serialNumber = 0;

    private AtomicInteger serialNumber=new AtomicInteger();

    @Override

    public void run() {

        try {

            Thread.sleep(200);

        } catch (InterruptedException e) {

        }

        System.out.println(Thread.currentThread().getName() + "："+getSerialNumber());

    }

    public int getSerialNumber() {

        return serialNumber.getAndIncrement();

    }

}

4.ConcurrentHashMap锁分段机制

5.CountDownLatch闭锁

6.实现Callable接口

7.Lock同步锁

8.Condition控制线程通信

9.线程八锁

10.线程按序交替

11.ReadWriteLock读写锁

12.线程池

13.线程调度

14.ForkJoinPool分支/合并框架工作窃取