JAVA并发编程实战——构建块

已于 2022-05-03 17:09:13 修改
阅读量649 收藏
点赞数 4
分类专栏： java并发学习 文章标签： java 后端
于 2022-04-30 22:36:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36566262/article/details/124515248
版权

目录

思维导图在这里插入图片描述

1 同步容器

如java的Vector和Hashtable

这些容器通过封装它们的状态，并对每一个公共方法进行同步实现了线程安全。

1.1 同步容器的问题

  1. 并发程度小，一次只能有一个线程访问。
  2. 对于复合操作，需要外部添加额外的代码同步。

示例代码：

public class SynchronousExampleOne {

    public static Object getLast(Vector<Object> vector) {
        int last = vector.size() - 1;
        return vector.get(last);
    }

    public static void deleteLast(Vector<Object> vector) {
        int last = vector.size() - 1;
        vector.remove(last);
    }
    
}

如果两个线程分别同时访问getLast和deleteLast可能出现如下情况：
在这里插入图片描述
可以看出会出现非预期的结果。

此时我们需要在方法上加synchronized进行同步。

1.2 迭代器和并发修改异常(ConcurrentModificationException)

在设计同步容器的迭代器时，没有考虑并发修改的问题，它们是及时失败——fail-fast的，当在迭代过程发现被修改，将会抛出ConcurrentModificationException。
示例代码：

public class ConcurrentModificationExample {
    private List<Integer> list = Collections.synchronizedList(new ArrayList<>());
    public ConcurrentModificationExample()  {
        list.add(1);
        list.add(12);
        list.add(13);
    }

    public static void main(String[] args) {
        ConcurrentModificationExample testObject = new ConcurrentModificationExample();
        Thread thread = new Thread(() -> {
            for (int i = 10; i < 100; i++) {
                testObject.list.add(i);
            }
        });
        thread.start();
        for (Integer o: testObject.list) {
            System.out.println(o);
        }
    }
}

运行结果：
在这里插入图片描述

解决方法：迭代期间对容器加锁，或者使用迭代器的add和remove方法进行元素添加和移除。

2 并发容器

Java5.0 提供了几种并发的容器改进了同步容器，如ConcurrentHashMap和CopyOnWriteArrayList。

用并发容器替代同步容器，可以显著的提高扩展性和并发性。

2. 1 ConcurrentHashMap

ConcurrentHashMap同样是哈希表，但是拥有更加细化的锁机制：分段锁，读写线程可以并发的访问map，同时还支持并发的修改map不同分段。

参考如下put源码：
在这里插入图片描述

可见并发的修改是基于分段的，只能并发加锁修改不同的哈希表索引分段。

同时ConcurrentHashMap修改了同步容器迭代器的并发修改失败，迭代过程允许并发修改。

2.2 并发容器附加的原子操作

类似同步容器，并没有提供缺少就加入这种原子操作。而并发容器已经实现这些原子操作，不需要外部额外的代码进行同步。
如下并发容器顶级接口：
在这里插入图片描述
已经默认定义了复杂操作的原子操作定义，由实现类实现。

2.3 CopyOnWriteArrayList

同步list的并发替代，通过写时复制，避免对容器进行加锁。
它的add操作如下

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

可见添加是：通过内部lock锁对数据先复制一份，然后进行修改，之后再赋值给原数组。只能一个线程进行add操作。
而读取操作一直是对原数组进行操作，可以多个线程进行，不受修改线程影响。

3 阻塞队列和生产者-消费者模型

阻塞队列提供可阻塞的put和take方法，同时支持中断响应。

如下是BlockQueue接口定义的方法：
在这里插入图片描述
可以看出put和take都是阻塞方法(抛出中断异常)，也就是说如果put一个满的队列和take一个空的队列会导致线程进入阻塞状态。而支持中断则可以中断这种阻塞状态。

常见的生产者-消费者模式是线程池和工作队列相结合。

如下实例演示生产者-消费者模式：


@Data
@NoArgsConstructor
public class ProducerAndConsumerExample {
    private BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(10);


    public static void main(String[] args) {
        ProducerAndConsumerExample exampleObject = new ProducerAndConsumerExample();
        Thread produce = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    System.out.println("生产整数：" + i);
                    exampleObject.blockingQueue.put(i);
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + "被中断了");
                    e.printStackTrace();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("消费整数：" + exampleObject.blockingQueue.take());
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + "被中断了");
                    e.printStackTrace();
                }
            }
        });
        produce.start();
        consumer.start();
    }

}

运行结果：
在这里插入图片描述

由BlockQueue作为工作队列，使得生产者和消费者进行解耦，具体操作都绑定到对工作队列的操作上。

4 阻塞和可中断方法

阻塞可能会因为IO操作未结束、等待获取锁或等待线程唤醒Thread.sleep。

阻塞操作和普通操作区别：被阻塞线程必须等待一个事件的发生才能继续进行，并且这个事件是不处于它控制的。

阻塞队列中的put和take就是阻塞方法，因为抛出了中断异常InterruptedException，意味着如果线程被中断，则该方法抛出中断异常，线程提前结束阻塞状态。

中断是一种协作机制。

当我们调用一个阻塞方法时需要注意如何处理中断，通常有以下两种操作：

  1. 传递InterruptedException，将该异常交给调用方进行处理。
  2. 恢复中断，比如如果捕获该异常，需要进行恢复中断，而不能不做任何响应。

如下demo:

public class InterruptedExample extends Thread {
    private BlockingQueue<Integer> blockingQueue;
    @Override
    public void run() {
        try {
            blockingQueue.take();
        } catch (InterruptedException e) {
            //正确——恢复中断，设置中断状态位true
            Thread.currentThread().interrupt();
            
            //错误——什么都不做
            
        }
    }
}

我们应该捕获，并设置中断位，不能不做处理。

5 Synchronizer同步器

Synchronizer同步器是一个对象，根据本身的状态控制调节线程的控制流。

处理上述的阻塞队列，其他类型的同步器有：信号量(semaphore)、关卡(barrier)和闭锁(latch)等。

5.1 闭锁

闭锁是一种同步器，它可以延迟线程的进度直到线程到达终止。

比如CountDownLatch就是一个闭锁实现，运行一个或多个线程等待一个事件集的发生。

countDown方法对计数器做减一操作，表示一个事件已经完成。
await方法等待计数器达到0，此时所有等待事件都发生。如果计数器非零，await会一直阻塞到计数器为0，或者等待线程中断或超时。

CountDownLatch常用于启动和停止线程，如下示例demo：

public class CountDownLatchExample {
    public long timeTasks(int nThreads, Runnable task) {
        Assert.isTrue(nThreads>0, "线程个数必须大于0");
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);
        for (int i = 0; i < nThreads; i++) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    try {
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            endGate.countDown();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            thread.start();
        }
        long start = System.currentTimeMillis();
        startGate.countDown();
        try {
            endGate.await();
            long end = System.currentTimeMillis();
            return end - start;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return 0L;
        }
    }
}

通过两个countdownlatch来计算执行时间。

5.2 FutureTask

FutureTask同样可以作为闭锁，它的计算通过Callable实现可以返回一个计算结果。

FutureTask有三种状态：等待、运行和完成。
完成包括：正常结束、取消和异常(InterruptedException | ExecutionException)

以下demo是一个演示FutureTask异步处理获取结果的示例：

public class FutureTaskExample {
    private int count = 1;
    private FutureTask<Integer> futureTask = new FutureTask<>(() -> {
        Thread.sleep(5000);
        int res = 100 / count;
        System.out.println("计算完成：");
        return 100;
    });
    private Thread thread;
    public void startThread(FutureTask<Integer> futureTask) {
        thread = new Thread(futureTask);
        thread.start();
    }

    public static void main(String[] args) {
        FutureTaskExample futureTaskExample = new FutureTaskExample();
        futureTaskExample.normalExecution();
        futureTaskExample.InterruptedExceptionExecution();
        futureTaskExample.ExeExceptionExecution();
    }

    public void normalExecution() {
        FutureTaskExample futureTaskExample = new FutureTaskExample();
        futureTaskExample.startThread(futureTaskExample.futureTask);
        futureTaskExample.count = 0;
        try {
            System.out.println("---------正常完成计算----------");
            System.out.println(futureTaskExample.futureTask.get());
        } catch (ExecutionException e) {
            System.out.println("执行异常处理");
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.out.println("中断异常处理");
            e.printStackTrace();
        }
    }


    public void ExeExceptionExecution() {
        FutureTaskExample futureTaskExample = new FutureTaskExample();
        futureTaskExample.startThread(futureTaskExample.futureTask);
        try {
            System.out.println(futureTaskExample.futureTask.get());
        } catch (ExecutionException e) {
            System.out.println("执行异常处理");
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.out.println("中断异常处理");
            e.printStackTrace();
        }
    }

    public void InterruptedExceptionExecution() {
        FutureTaskExample futureTaskExample = new FutureTaskExample();
        futureTaskExample.startThread(futureTaskExample.futureTask);
        Thread.currentThread().interrupt();
        try {
            System.out.println(futureTaskExample.futureTask.get());
        } catch (ExecutionException e) {
            System.out.println("执行异常处理");
            e.printStackTrace();
        } catch (InterruptedException e) {
            System.out.println("中断异常处理");
            e.printStackTrace();
        }
    }
}

运行结果如下：
在这里插入图片描述
结果显示了计算完成的三种状态：正常结束、任务执行异常比如运行时异常和调用线程被中断，不再进行阻塞等待结果。

5.3 信号量Semaphore

计数信号量：用于控制共享访问特定资源活动的数量。
Semaphore管理permit许可集来进行访问控制，只要还有permit就允许访问。如果没有acquire会被阻塞，直到有permit被释放。

信号量Semaphore示例如下，测试一个同时只允许三个线程访问的资源，访问过程：

public class SemaphoreExample {
    private  Semaphore semaphore;
    private Set<String> resource = new HashSet<>();
    public SemaphoreExample(int permit) {
        resource.add("Beijing");
        resource.add("Shanghai");
        resource.add("Xian");
        semaphore = new Semaphore(permit);
    }

    public void readResource() {
        try {
            this.semaphore.acquire();
            System.out.println(Thread.currentThread().getName()+ "获取成功——打印获取的资源");
            for (String s: this.resource
                 ) {
                System.out.println(s);
            }
            //休眠长时间观察，permit获取释放情况
            Thread.sleep(50000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            this.semaphore.release();
        }
    }

    public static void main(String[] args) {
        SemaphoreExample semaphoreExample = new SemaphoreExample(3);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                semaphoreExample.readResource();
            });
            thread.start();
        }
    }
}

前期运行结果:

在这里插入图片描述
可见一开始只有三个线程获取了permit执行了资源访问，之后过了50s当休眠结束，线程释放permit才开始唤醒阻塞的其余线程。

5.4 关卡CyclicBarrier

CyclicBarrier阻塞一组线程，使他们相互等待，直到最后一个线程到来，在一起执行一个屏障点内容。

CyclicBarrier：构造函数：
在这里插入图片描述

第一种：设置参与线程数，和所有线程都到达屏障点后，由最后一个到达者执行传入的barrierAction。
第二种：只设置线程数，达到屏障点后不做action，各自继续执行。

示例demo：

public class CyclicBarrierExample {
    private CyclicBarrier cyclicBarrier;

    public CyclicBarrierExample(int nthread) {
        cyclicBarrier = new CyclicBarrier(nthread, () -> {
            System.out.println("全部到达屏障点——执行屏障runnable");
            System.out.println("合并子任务");
        });
    }

    public static void main(String[] args) {
        CyclicBarrierExample cyclicBarrierExample = new CyclicBarrierExample(2);
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(() -> {
            System.out.println("线程" + Thread.currentThread().getName() + "达到屏障点");
            System.out.println("执行子任务");
            try {
                cyclicBarrierExample.cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        });

        executorService.submit(() -> {
            System.out.println("线程" + Thread.currentThread().getName() + "达到屏障点");
            System.out.println("执行子任务");
            try {
                cyclicBarrierExample.cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
    }
}

运行结果：
在这里插入图片描述

可见只有全部线程都到达，才会执行barrierAction。

参考文献

[1], 《JAVA并发编程实战》.

LamaxiyaFc
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记
12-27
SSM实战项目——Java高并发秒杀API是一个深入学习Java后端开发的重要实践，它涵盖了Spring、SpringMVC和MyBatis三大框架的整合应用，以及如何处理高并发下的秒杀场景。在这个项目中，我们将深入理解如何设计并实现一...
JAVA入门学习 — 构造代码块
weixin_67614925的博客
04-21 4220
目录构造代码块的了解构造代码块的实例应用 构造代码块的了解 {…}花括号包裹起来的代码我们称之为代码块或代码段。 只有一对花括号包裹起来的代码我们称之为构造代码块。 构造代码块与构造方法一样都是在类被实例化的过程中被调用的。 构造代码块在构造方法之前先执行。 类每次被实例化的过程中都会调用构造代码块。 构造代码块的实例应用 import lombok.Getter; import lombok.Setter; @Getter @Setter public class Person06 { pr
java构造代码块、局部代码块、静态代码块
gaoiqyemanren的博客
02-05 215
java代码块三类代码块区别，与执行知识点
一文详解：Java中，父子类静态块、构造块、构造方法、成员变量之间的初始化先后顺序与执行先后顺序
chenyu_Yang的博客
12-10 696
静态成员变量由static修饰，与静态代码块加载顺序是同一级别的，但是，若静态代码块中使用了某个成员变量，那么该成员变量必须声明在静态代码块之前（这时，静态成员变量比静态代码块先加载）父类静态成员变量/静态代码块/静态成员方法--->子类静态成员变量/静态代码块/静态成员方法。--->父类普通成员变量/普通成员方法--->父类构造代码块--->父类构造方法。--->子类普通成员变量/普通成员方法--->子类构造代码块--->子类构造方法。--->父类构造代码块--->父类构造方法。
Java：构造代码块
weixin_45716563的博客
02-14 601
Java：构造代码块
【java基础】构造方法、构造代码块、静态代码块
m0_49622667的博客
10-24 1403
一、 构造方法 构造方法为java中常见的方法，一般使用new关键字实例化新对象时会被调用，用于完成初始化操作 new执行过程一般分为两步：1.为对象分配内存空间。2.调用对象的构造方法。 在写构造方法时要注意以下三点： 方法名称必须与类名称相同 构造方法中没有返回值类型声明 每一个类中一定至少存在一个构造方法若在编写时没有定义构造方法，则编译器自动生成一个无参构造 比如： class Person { private String name;//实例成员变量 private int age;
SSM实战项目——Java高并发秒杀API.zip
08-17
SSM实战项目——Java高并发秒杀API是一个典型的Java Web开发案例，主要涉及Spring、SpringMVC和MyBatis这三大框架的整合应用。在这个项目中，开发者将学习如何构建一个能够处理高并发请求的秒杀系统，以满足电商或...
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记.zip
01-14
这个Java实战项目提供了详细的步骤和学习笔记，涵盖了从需求分析、架构设计到代码实现的全过程，是提升Java并发编程和分布式系统设计能力的宝贵资源。通过实际操作，你可以深入了解SSM框架的使用以及在高并发场景下...
Java之构造函数、构造代码块、局部代码块、this
NoviceZ的博客
06-08 520
构造方法的定义 普通方法的定义：修饰符 返回值类型 方法名(参数列表){方法体} 构造方法的定义：修饰符 方法名【与类同名】(参数列表){方法体} package cn.tedu.demo2; /** * @Author 作者：曾龙 * @Projiect 项目：Demo2 * @Time 时间：2021/6/8 10:11 */ public class TestConstructor { public static void main(String[] args) { ...
Java基础学习——3.6构造块
weixin_64195726的博客
02-15 789
构造块又称为构造代码块，是可以在类中直接定义的代码块。 class Student5{ String name; int age; { System.out.println("构造代码块"); //构造块部分为{}中的内容 } //构造方法 public Student5(){ System.out.println("构造方法"); } } public class 代码块 { public stat
java ：构造代码块 和 静态代码块
weixin_63211952的博客
03-08 155
java ：构造代码块 和 静态代码块 的理解
java构造块与静态块
zzzzzztt的博客
04-07 1万+
最近，在面试题或者面试上老是，提到静态块，静态变量，就仔细了解了下。Java类里普遍存在静态快，构造块，构造函数，具体什么关系呢？静态块：用static申明，JVM加载类时执行，仅执行一次构造块：类中直接用{}定义，每一次创建对象时执行public class Study_static { public static char text = 'a'; //静态对象 public Stud...
java 构造函数 和 构造代码块
newxuyangcao
03-12 1559
构造函数也叫构造方法 1、方法名与类名相同。 2、不用定义返回值类型。 3、为对象进行初始化的特殊函数。 4、对象一建立，就会调用与之对应的类的构造函数。 5、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。 6、但是当在类中自定义了构造函数后，默认的构造函数就没有了。  7、默认构造构造函数的权限是随着的类的变化而变化的。例如
java代码块（普通块、构造块、静态块）
老痒的农舍
03-29 1785
1.普通块方法体内部由大括号{}括起，执行顺序为按照正常的执行顺序（先出现，先执行）执行。2.构造块类的内部由大括号{}括起，每次构造对象时都会被调用，且优先于构造函数执行。3.静态块（在此借鉴https://blog.csdn.net/qq_27093465/article/details/75339803）在类的内部使用，形式为static{}，静态块一般用于初始化类，为类的属性初始化，每个静...
JAVA构造块等知识
qq_42594923的博客
08-10 389
初始化块 初始化块是JAVA类中可出现的第4种成员，块内可包含执行语句，初始化块是构造器的补充，初始化块总是在构造器执行之前执行。 分为四类：局部代码块、构造代码块、静态代码块、同步代码块 局部代码块： ...
java 构造块_java中构造方法、普通块、静态代码块、构造块的执行顺序
weixin_30150003的博客
02-12 553
静态块、构造块、构造方法、普通块静态块：在类中用"{}"括号括起来,并在括号前用static修饰的块为静态块;静态块在类加载时候被调用,并且在整个生命中只调用一次同步块使用synchronize关键字修饰,并使用"{}"括起来的代码片段.它表示在同一时间只能有一个线程进入到该方法块中,是一种多线程保护机制.构造块:在类中直接使用"{}"括起来的代码被称为构造块;构造方法:在对象被创建时调用;普通块...
Java四种代码块
u012804721的博客
09-05 1万+
在java中用{}括起来的称为代码块，代码块可分为以下四种： 1.普通代码块：    类中方法的方法体 2.构造代码块：    构造块会在创建对象时被调用，每次创建时都会被调用，优先于类构造函数执行。 3.静态代码块：    用static （）包裹起来的代码片段，只会执行一次。静态代码块优先于构造块执行。 4.同步代码块：    使用synchronized（）{  } 包裹起来
详解java中的四种代码块
evilcry2012的专栏
03-09 2万+
详解java中的四种代码块 转载  2017-12-07   作者：krisll    我要评论 这篇文章主要介绍了详解java中的四种代码块，具有一定借鉴价值，需要的朋友可以参考下。 在java中用{}括起来的称为代码块，代码块可分为以下四种： 一.简介 1.普通代码块： 类中方法的方法体 2.构造代码块：
Java静态代码块、构造代码块、构造方法的执行顺序
热门推荐
__kingzone__的专栏
04-12 3万+
Java静态代码块、构造代码块、构造方法的执行顺序静态代码优先于非静态的代码，是因为被static修饰的成员都是类成员，会随着JVM加载类的时候加载而执行，而没有被static修饰的成员也被称为实例成员，需要创建对象才会随之加载到堆内存。所以静态的会优先非静态的。 执行构造器（构造方法）的时候，在执行方法体之前存在隐式三步： 1，super语句，可能出现以下三种情况： 1）构造方法体的第一行是
从0开始深入理解并发、线程与等待通知机制
最新发布
02-28
从互联网公司的招聘需求可以看到，大厂的 Java 岗的并发编程能力属于标配。 而在非大厂的公司，并发编程能力也是面试的极大加分项， 而工作时善用并发编程则可以极大提升程序员在公司的技术话语权

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LamaxiyaFc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值