JavaSE进阶知识学习----多线程JUC高级知识-2

最新推荐文章于 2024-05-01 03:02:07 发布
最新推荐文章于 2024-05-01 03:02:07 发布
阅读量481 收藏
点赞数 1
分类专栏： 多线程JUC JAVA进阶学习 文章标签： 多线程 juc java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27922023/article/details/79168487
版权

1.Java JUC简介

在java5.0之后提供了一个java.util.concurrent包（简称JUC），此包中增加了很多在并发编程中常用的工具类，用于定义类似于线程的自定义系统，包括线程池，异步IO等等。

2.volatile关键字-内存可见性

内存可见性问题：当多个线程同时操作共享数据时，彼此不可见。图解如下：

当主存有一个flag数据时，线程1负责修改flag的值，Main线程负责读取flag的值，线程1修改值之前，先将flag= false取到自己手中，然后再修改其值，当线程1还没将修改好的值放进主存中，Main线程已经从主存读到了flag= false，然后main线程就执行自己的逻辑，这就是内存可见性的问题，就是说Main线程不知道其他线程执行结束没有。
代码说明如下：

public class TerstVolatile {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        new Thread(td).start();
        while (true) {
            if(td.isFlag()){
                System.out.println("-------------------");
                break;
            }

        }
    }

}
class ThreadDemo implements Runnable{
    private boolean flag = false;

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("flaf="+isFlag());

    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

解决办法之一：使用synchronize关键字加锁

public class TerstVolatile {
    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;
                }
            }
        }
    }
}

但是加锁会导致效率变低，解决办法之二使用volatile关键字，如下图：

使用了volatile关键字就是线程直接操作主存中的数据。在保证数据的同步性，效率也得以提升。volatile相较于synchronize是一种较为轻量的同步策略。

private volatile boolean flag = false;

注意：
1. volatile不具备互斥性，互斥性就是说如果多个线程共同抢一把锁的时候，如果其中一个线程抢到锁，那么其他线程就只能等待，volatile就是多个线程共同在主存中完成。
2. volatile不能变量的原子性，

有关原子性的问题，我们看一个i++的实例

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 int serialNumber = 0;
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+getSerialNumber());
    }
    public int getSerialNumber(){
        return serialNumber++;
    }

}

结果为：

Thread-1:0
Thread-0:1
Thread-8:2
Thread-9:5
Thread-6:7
Thread-5:3
Thread-3:3
Thread-2:4
Thread-4:8
Thread-7:6

说明：
1. i++在程序底层其实是三步走，读-改-写，本来是不可分割的操作，但是在多个线程访问时，一个线程还没写成功，另外一个线程也开始写了，这也就是线程安全问题。
2. 使用volatile也不能解决这个问题，因为volatile是让多个线程在内存中共同操作共享数据，i++的操作也会被分割成三步。
3. 解决办法就是使用原子变量。

3.原子变量-CAS算法

jdk1.5之后java.concurrent.atomic包下提供了常用的原子变量，原子变量使用volatile保证内存可见性，使用CAS算法保证数据的原子性。CAS算法是硬件对于并发操作共享数据的支持，CAS包含了三个操作数，分别为：内存值V,预估值A,更新值B,当且仅当V==A,V=B,否则，不做任何操作。

java.concurrent.atomic包下的类结构

AtomicInteger类的方法如下，其他类的参考API
1. int addAndGet(int delta) ;以原子方式将给定值与当前值相加。
2. boolean compareAndSet(int expect, int update) ;如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
3. int decrementAndGet() ;以原子方式将当前值减 1。
4. double doubleValue() ; 以 double 形式返回指定的数值。
5. float floatValue() ;以 float 形式返回指定的数值。
6. int get() ;获取当前值。
7. int getAndAdd(int delta) ;以原子方式将给定值与当前值相加。
8. int getAndDecrement() ;以原子方式将当前值减 1。
9. int getAndIncrement() ;以原子方式将当前值加 1。
10. int getAndSet(int newValue) ; 以原子方式设置为给定值，并返回旧值。
11. int incrementAndGet(); 以原子方式将当前值加 1。
12. int intValue() ;以 int 形式返回指定的数值。
13. void lazySet(int newValue) ;最后设置为给定值。
14. long longValue() ;以 long 形式返回指定的数值。
15. void set(int newValue) ;设置为给定值。
16. String toString() ;返回当前值的字符串表示形式。
17. boolean weakCompareAndSet(int expect, int update) ;如果当前值 == 预期值，则以原子方式将该设置为给定的更新值。

使用原子变量改写上述程序如下：

class AtomicDemo implements Runnable{
    private AtomicInteger serialNumber = new AtomicInteger();
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+getSerialNumber());
    }
    public int getSerialNumber(){
        return serialNumber.getAndIncrement();
    }
}

4.ConcurrentHashMap锁分段机制

ConcurrentHashMap同步容器类是java5增加的一个线程安全的哈希表，对于多线程的操作，介于HashMap和HashTable之间，内部采用锁分段的机制替代HashTable的独占锁，进而提高了性能。包结构如下：

当期望许多线程访问一个给定Collection时，ConcurrentHashMap通常优于HashMap，当期望的读数和遍历远远大于列表的更新读数时CopyOnWriteArrayList优于ArrayList。
ConcurrentHashMap锁分段机制图解如下：

CopyOnWriteArrayList实例如下：如果我们不使用 CopyOnWriteArrayList，使用 Collections.synchronizedList运行下面程序就会报并发修改异常。

public class TestCopyOnWriteArrayList {
    public static void main(String[] args) {
        HelloThread ht = new HelloThread();
        for (int i = 0; i < 10; i++) {
            new Thread(ht).start();
        }
    }
}
class HelloThread implements Runnable{
    private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
    static{
        list.add("AA");
        list.add("BB");
        list.add("CC");
    }
    @Override
    public void run() {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            list.add("DD");
        }
    }
}

异常如下：

java.util.ConcurrentModificationException

使用 CopyOnWriteArrayList修改代码如下所示：

private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();

说明：CopyOnWriteArrayList：写入并复制，就是每次写入的时候都会复制，如果添加操作多时，效率低，每次都会进行复制，开销很大，并发迭代操作多时可以选择。

5.CountDownLatch闭锁

CountDownlatch闭锁，就是在完成某些运算时，只有其他所有线程的运算全部完成，当前运算才继续执行。
实例如下：如果不使用CountDownlatch闭锁就无法计算出执行10子线程所需要的时间

public class TestCountDownlatch {
    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(5);
        LatchDemo ld = new LatchDemo(latch);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            new Thread(ld).start();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗费时间为："+(end-start));
    }

}
class LatchDemo implements Runnable{
    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) {
        this.latch = latch;
    }
    @Override
    public void run() {
        for (int i = 0; i < 50000; i++) {
            if(i % 2 ==0){
                System.out.println(i);
            }
        }
    }
}

使用CountDownlatch闭锁的实例如下，可以计算出所有子线程执行需要的时间。

public class TestCountDownlatch {
    public static void main(String[] args) {
        //5 和子线程数目一致
        final CountDownLatch latch = new CountDownLatch(5);
        LatchDemo ld = new LatchDemo(latch);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(ld).start();
        }
        //等待所有的子线程全部执行完
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗费时间为："+(end-start));
    }

}
class LatchDemo implements Runnable{
    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) {
        this.latch = latch;
    }
    @Override
    public void run() {
        synchronized(this){
            try {
                for (int i = 0; i < 50000; i++) {
                    if(i % 2 ==0){
                        System.out.println(i);
                    }
                }
            }finally{
                latch.countDown();// 减一操作
            }
        }

    }
}

6.实现Callable接口

创建执行线程的方式：四种方式
  1. 定义Thread子类，并重写run方法，创建Thread子类实例，也就是线程对象，再调用线程对象的start方法。 new Thread子类对象.start();
  2. A类实现Runnable接口，重写run方法，创建Runnable实现类的实例A a = new A(); new Thread(a).start();

  3. 实现Callable接口，方式如下：

    public class TestCallable {
    public static void main(String[] args) {
    CallableThreadDemo ctd = new CallableThreadDemo();
    //执行Callable方法，需要FutureTask实现类的支持，用于接收运算返回的结果
    //FuterTask是Future接口
    FutureTask result = new FutureTask(ctd);
    new Thread(result).start();
    //接收线程的返回值,当子线程执行结束result.get()才执行，和闭锁类似
    //所以FutureTask也可以用于闭锁
    try {
    Integer sum = result.get();
    System.out.println(sum);
    } catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
    }
    }
    }
    class CallableThreadDemo implements Callable{

    @Override
public Integer call() throws Exception {
    int sum = 0;
    for (int i = 0; i < 100; i++) {
        System.out.println(i);
        sum +=i;
    }
    return sum;
}

    }
    说明：实现Callable接口和实现Runnable接口的不同在于实现Callable接口有返回值和异常抛出。

四川码匠
关注
专栏目录
JUC 多线程
m0_46499246的博客
03-30 263
JUC 多线程介绍 1、 线程的生命周期 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行； 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状
JavaSE学习总结（二十）多线程进阶之JUC并发（上）/虚假唤醒/JUC解决生产者消费者问题/精准通知唤醒/读写锁/线程八锁问题/集合线程安全化/JUC常用辅助类/阻塞队列/同步队列
ZaynFox的博客
03-29 287
一、什么是JUC？ JUC就是Java的并发包java.util.concurrent的简写，是关于并发编程的API。 与JUC相关的有三个包：java.util.concurrent、java.util.concurrent.atomic、java.util.concurrent.locks。 二、并发和并行的区别 并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。（同一时间段）（通俗地讲：C
Java多线程JUC
昨夜凛雨
08-20 446
1. volatile 关键字多线程访问的时候，一个比较严重的问题就是内存不可见，其实在内存访问的时候每一个线程都有一个自己的缓冲区，每次在做修改的时候都是从主存取到数据，然后放到自己的缓冲区中，在做完修改之后放回主存。这样每一个线程之间的变量是不可见的。造成读到的数据可能始终就是错误的，因此有一个关键字可以使得这个共享变量称为透明的。就好像所有的操作就直接是在内存中操作一样，因为他一直不停的去同步
java多线程--“锁”总览
节至
07-01 2292
根据锁的添加到Java中的时间，Java中的锁，可以分为"同步锁"和"JUC包中的锁"。 同步锁 　　即通过synchronized关键字来进行同步，实现对竞争资源的互斥访问的锁。Java 1.0版本中就已经支持同步锁了。 　　同步锁的原理是，对于每一个对象，有且仅有一个同步锁；不同的线程能共同访问该同步锁。但是，在同一个时间点，该同步锁能且只能被一个线程获取到。这样，获取到同步锁的线程就能
Java JUC
gitnote的博客
01-27 99
Java JUC 简介 在Java 5.0 提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection 实现等。 volatile 关键字-内存可见性 内存可见性 内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态
java多线程系类：JUC集合：01之框架
weixin_33888907的博客
01-06 273
概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括：Java集合包JUC中的集合类 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3498454.html   Java集合包 在“Java 集合系列01之 总体框...
2024年Java学习路线图（适合自学详细版）_java架构师技术进阶路线图
最新发布
2401_84253089的博客
05-01 2454
Java程序员核心技术必备，设计模式，快速通透！学习常见的数据架构和算法，建立其良好的编程思维，形成自己的编程思想。掌握各种算法，提升自己的编程能力。掌握基本的数据结构，加深对程序底层的理解。利用编程思维解决生活和工作中的各种问题。数据库技术是软件开发中的必备技能，咱们从数据库基本操作到掌握数据库设计的能力，层层深入学习数据库设计思想，一个软件项目的底层逻辑中，数据的存储结构是重中之重，因此，数据库技术也是面试中常被面试官拿来考察面试者的必用问题。
Java高级工程师系列学习路线介绍，成功拿到offer
天真爱器
06-25 299
前言 从短期来看，程序员的确算是个不错的工作，薪水也比一般岗位高很多；但是从长远来看，程序员的中年危机会比其他岗位来的更早，很多程序员只有到了35岁左右，才能真正认清楚互联网行业，尤其是被裁之后，找工作无门的这种无奈。很多人说那只是你技术不过关，又或者没有管理能力，但实际上又有多少程序员在35岁能当上高管呢？ 最近在职场论坛上看到这样一个帖子：37岁程序员被裁，120天没找到工作，面试华为阿里均被拒，无奈降薪去小公司后蒙了！这是怎么回事呢？ 正文 下文中截图来源于朋友一个pdf版本的面经，把所以知识点的答
JavaSE进阶知识学习----多线程JUC高级知识-5
疾风知劲草，智者必怀仁
01-26 277
11.线程池 先看一个简单的实例 public class TestThreadPool { public static void main(String[] args) { ThreadPoolDemo td = new ThreadPoolDemo(); new Thread(td).start(); new Thread(td).s
Java学习路线！Java高级工程师系列学习路线介绍
m0_57286472的博客
07-08 307
正文 下文中截图来源于朋友一个pdf版本的面经，把所以知识点的答案整理了下来，耗费他至少1个月时间，在本文最后部分把这个pdf分享给大家，觉得有用的麻烦点赞关注走一波，谢谢！！！面经中有他的知识点的答案，如下图示例，非常详细（文末有领取方式）！！！ 1.数据结构与算法篇 你是java开发你就用java代码去实现 书籍参考： （0）《图解算法》入门（1）《剑指offer》 剑指Offer_编程题_牛客网（2）《程序员代码面试指南 IT名企算法与数据结构题目最优解》参考左神视频（3）leetcode Lee
JUC多线程
Randy的博客
07-25 332
JUC多线程 什么是JUC：源码+官方文档，面试高频问！ Runnable 、callable 1.线程和进程 进程：一个程序，QQ.exe等程序的集合，一个进程可以包含多个线程，至少包含一个！ java默认两个线程：2个，main、GC 线程：Thread，Runnable、Callable 2.回顾多线程 java是否可以开启线程？ 答：不可以！ public synchronized void start() { if (threadStatus != 0)
JavaSE进阶知识学习----多线程JUC高级知识-3
疾风知劲草，智者必怀仁
01-26 261
7.Lock同步锁 解决线程安全问题的方式，使用synchronize隐式锁，1.同步代码块，2.同步方法，3.java5之后使用同步锁Lock：显示锁，也就是说必须通过lock()方法上锁，通过unlock()方法释放锁。 实例如下： public class TestLock { public static void main(String[] args) { T
Java及大数据学习路线.pdf
12-24
- **高级主题**：如JVM内存模型、参数调优，JUC（并发包）线程高级特性，以及Docker虚拟化容器。 **大数据学习路线** 1. **JavaSE** 和 **JavaEE核心** 的内容与Java学习路线相同。 2. **Hadoop生态体系**： -...
多线程~juc
张华的博客
01-09 1350
1.juc相关概念 1.1进程/线程 1)进程:是一个程序运行的最小单位(巧记：先"进"来，然后才能看到线程) 2)线程:是进程里最小的运行单位(例如idea进程,里面有多个微服务在运行,就是线程) 3)线程的6种状态: NEW(新生态),RUNNABLE(运行态),BLOCKED(阻塞态),WAITING(无限等待),TIMED_WAITING(有限等待),TERMINATED(死亡态) 1.2并发/并行 并发: 在相对的一段时间内,其实是很短,对计算机有感,对人无感,多个线程抢占资源来执行自
多线程之JUC
m0_57698935的博客
09-27 567
多线程之JUC 1、什么是JUC？ JUC是java.util.concurrent的简写 在jdk官方手册中可以看到JUC相关的jar包有三个。 JUC的意思就是java并发编程工具包 并发编程的本质就是充分利用CPU资源 进程、线程 进程 进程是指在系统中正在运行的一个应用程序，程序一旦运行就是进程。 进程是系统进行资源分配的独立实体， 且每个进程拥有独立的地址空间。 一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。 线程 线程是进程的一个实体，是进程的一条执行路径。 线程是CPU独立运行和独
多线程和JUC
weixin_44093711的博客
11-12 1341
进程 进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有他自己的内存空间和系统资源 多进程意义在于计算机可以执行多个任务，提高cpu使用率 我们在一边玩游戏，一边听音乐的时候，是cpu在做着程序间的高效切换让我们觉得是同时进行的 线程 线程是依赖于进程而存在的，在一个进程内又可以执行多个任务，而这每个任务我就可以看出是一个线程 线程：是程序的执行单元，执行路径。是程序使用cpu的最基本单位。 单线程：程序只有一条执行路径 多线程：程序有多条执行路径 多线程意义在于提高应用程序的使用率
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值