带你了解java的JUC的使用

最新推荐文章于 2024-04-24 20:52:08 发布
最新推荐文章于 2024-04-24 20:52:08 发布
阅读量744 收藏
点赞数 1
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xb1964109474/article/details/105395804
版权

J.U.C包内的原子操作封装类

  • AtomicBoolean:原子更新布尔类型

  • AtomicInteger:原子更新整型

  • AtomicLong:原子更新长整型

  • AtomicIntegerArray:原子更新整型数组里的元素

  • AtomicLongArray:原子更新长整型数组里的元素

  • AtoimcReferenceArray:原子更新引用类型数组里的元素

  • AtomicIntegerFieldUpdater:原子更新整型的字段的更新器

  • AtomicLongFieldUpdater:原子更新长整型字段的更新器

  • AtomicReferenceFieldUpdater:原子更新引用类型里的字段

  • AtomicReference:原子更新引用类型

  • AtomicStampedReference:原子更新带有版本号的引用类型（可用于解决ABA问题）

  • AtomicMarkableReference:原子更新带有标记的引用类型

1.8更新
计数器增强版，高并发下性能更好
更新器：DoubleAccumulator,LongAccumulator
计数器：DoubleAdder,LongAdder

原理：分成多个操作单元，不同线程更新不同的单元只有需要汇总的时候才计算所有单元的操作

场景：高并发频繁更新，不太频繁读的取的

Semaphore

/**
 *
 */
public class SemaphoreDemo {
    // Semaphore 信号量 限流 共享锁
    private static Semaphore semaphore=new Semaphore(6);

    public static void main(String[] args) {
        for (int i = 0; i <1000 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire(1);
                    System.out.println("线程正在执行===============================");
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(1);
                }
            }).start();
        }

    }
}

手写Semaphore

package cn.tk.myproject.lock;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class MySemaphore {

    private  Sync sync;

    public MySemaphore(int permit ) {
        this.sync=new Sync(permit);
    }

    public void acquire(int arg){
        sync.acquireShared(arg);
    }

    public void release(int arg){
        sync.releaseShared(arg);
    }

    class Sync extends AbstractQueuedSynchronizer {

        private int permit;

        public Sync(int permit) {
            this.permit = permit;
        }

        @Override
        protected int tryAcquireShared(int arg) {
            for (;;) {
                int state = getState();
                int next = state + arg;
                if (next <= permit) {
                    //可以获取锁
                    if (compareAndSetState(state, next)) {
                        return arg;
                    }

                }
            }
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            for (;;){
                int state = getState();
                if(state==0){
                    return  false;
                }
                if(compareAndSetState(state,state-arg)){
                    return  true;
                }
                return false;
            }

        }
    }


}

CountDownLatch

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    private  static  CountDownLatch countDownLatch=new CountDownLatch(4);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
               countDownLatch.countDown();
                System.out.println("开始执行代码");
            }).start();
        }
        Thread.sleep(2000L);
        countDownLatch.await();
        System.err.println("成功执行完毕");

    }
}

用法2：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    private  static  CountDownLatch countDownLatch=new CountDownLatch(1);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    System.out.println("准备执行！！");
                    countDownLatch.await();
                    System.out.println("开始执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        Thread.sleep(3000L);
        countDownLatch.countDown();
    }
}

手写CountDownLatch


package cn.tk.myproject.lock;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 共享锁，从指定值开始下降
 */
public class MyCountDownLatch {
    private final Sync sync;

    public MyCountDownLatch(int count) {
        this.sync=new Sync(count);
    }
    public void await(){
        sync.acquireShared(1);
    }
    public void countDown(){
        sync.releaseShared(1);
    }

    /**
     *     CountDownLatch就可以看做是一个共享锁
     *     初始状态，这个共享锁被获取了n次，
     *     每次countdown，相当于释放一次锁
     *     当锁释放完后，其他线程才能再次获得锁
     */
    class Sync extends AbstractQueuedSynchronizer{


        public Sync(int count) {
            setState(count);
        }

        @Override
        protected int tryAcquireShared(int arg) {
            return (getState() == 0) ? 1 : -1;
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }
}

CyclicBarrier

/**
 * 需要线程数达到要求才会被执行
 */
public class CyclicBarrierDemo {

    private static CyclicBarrier cyclicBarrier=new CyclicBarrier(4);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{

                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("正在执行============================");

            }).start();
            Thread.sleep(300L);
        }
    }
}

CyclicBarrier源码分析


package cn.tk.myproject.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyCyclecbarrier {
    private ReentrantLock reentrantLock=new ReentrantLock();

    private Condition condition=reentrantLock.newCondition();

    private  int count ;

    private final int parties;

    private Object gentation=new Object();

    public MyCyclecbarrier(int parties) {
        this.parties = parties;
        this.count=this.parties;
    }

    public void await(){
       final  ReentrantLock lock =this.reentrantLock;
       lock.lock();
       try{
           final Object g=gentation;
           int index=--count;
           if(index==0){
               //结束等待
               //唤醒等待队列
               nextGention();
               return;
           }
           //否则进入等待
           for (;;){//防止伪唤醒
               try {
                   condition.await();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               if(g!=gentation){
                   return;
               }
           }
       }finally {
           lock.unlock();
       }



    }

    private void nextGention() {
        condition.signalAll();
        count=parties;//重置数量
        gentation=new Object();
    }


}

FutureTask

package cn.tk.myproject.lock;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableDemo {


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableImpl callable=new CallableImpl();
        FutureTask<String> stringFutureTask = new FutureTask<>(callable);

        new Thread(stringFutureTask).start();
//        new Thread(stringFutureTask).start();


            System.out.println(stringFutureTask.get());
            System.out.println(stringFutureTask.get());


    }

    static class CallableImpl implements Callable<String> {

        @Override
        public String call() throws Exception {
            System.out.println("执行callable");
            return "操作成功";
        }
    }
}

FutureTask源码解析

package cn.tk.myproject.lock;

import java.util.concurrent.Callable;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public class MyFutureTask<T>  implements Runnable{

    private static final int NEW=0;

    private static final int RUNABLE=1;

    private static final int END=2;

    private  int state;

    private AtomicReference<Thread> ower=new AtomicReference<>(null);

    private LinkedBlockingDeque<Thread> water=new LinkedBlockingDeque<>();

    T result;

    private final Callable<T> callabll;

    public MyFutureTask(Callable<T> callabll) {
        this.callabll = callabll;
        state=NEW;
    }

    @Override
    public void run() {
        while (true){
            if(state!=NEW||!ower.compareAndSet(null,Thread.currentThread())) return;

            try {
                state=RUNABLE;
                result= callabll.call();
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                state=END;
                ower.set(null);
            }
            while (true) {
                Thread thread = water.poll();
                if (thread == null) return;
                LockSupport.unpark(thread);

            }

        }


    }
    public T get(){
        if(state!=END){
            //等待
            water.add(Thread.currentThread());
            LockSupport.park();
        }

        return result;
    }
}
bin_coder
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
JDK中多线程之JUC集合的JDK源码解读配合大神的一起看，秒懂。
MRA__S__的专栏
03-02 2091
一、    “JUC集合”01之框架 1)  概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括： Java集合包 JUC中的集合类 2)  Java集合包 在“Java 集合系列01之 总体框架”中，介绍java集合的架构。主体内容包括Coll...
Java中的JUC指什么？
mercedes_benz
07-12 715
在Java中，JUC通常指的是Java并发工具包（Java Concurrency Utilities），它是Java提供的一组用于处理多线程编程和并发操作的工具类和框架。JUC包含了很多有用的类和接口，用于管理并发访问、同步操作、线程池、原子操作、阻塞队列等。2. Conditions（条件）：用于线程间的协调和通信，比如通过await()和signal()方法实现等待、通知机制。通过使用JUC提供的类和接口，开发人员可以更方便地进行多线程编程和并发操作，提升程序的性能和可靠性。
Java JUC详解：深入理解并发编程工具包
最新发布
suqieer的博客
04-24 1048
java.util.concurrent：核心并发工具类，如ExecutorService、Semaphore、CountDownLatch等。java.util.concurrent.atomic：原子变量类，如AtomicInteger、AtomicLong、AtomicReference等。java.util.concurrent.locks：锁和同步器类，如ReentrantLock、ReadWriteLock、Condition等。
（并发编程学习04）JUC并发工具类的应用场景详解
a250029634的博客
07-17 447
JUC并发工具类的应用场景详解
Java笔记-JUC基础
虽然但是
02-09 438
JUC
Java并发编程的扩展库 JUC（java.util.concurrent）
Leon的博客
06-22 188
Java并发编程是一门复杂的技术，其中有一些难点需要特别注意。比如以下是一些Java并发编程过程中会遇到的问题以及难点：线程安全：多线程执行的代码必须是线程安全的，否则会产生竞态条件和其他问题。死锁：当多个线程因为互相等待其他线程释放锁而无法继续执行时，就会产生死锁。竞态条件：当多个线程试图同时访问同一个共享资源时，就会产生竞态条件。内存可见性：多个线程同时访问同一个变量时，可能会产生内存可见性问题，即一个线程对变量的修改不会立即被其他线程所感知。
java并发编程：juc线程池
08-09
而了解 Java 并发编程以及其中的 JUC（java.util.concurrent）线程池，对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...
java并发编程专题（九）----（JUC）浅析CyclicBarrier
08-18
主要介绍了java CyclicBarrier的相关资料，文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
主要介绍了java JUC）Semaphore的相关资料，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解下
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
主要介绍了java（JUC）ReentrantLock的的相关资料，文中讲解非常详细，实例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
java并发编程专题（十）----(JUC原子类)基本类型详解
08-18
主要介绍了java JUC原子类基本类型详解的相关资料,文中示例代码非常详细，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
JUC详解（各种乱七八糟的锁）
qdyones的博客
02-19 2422
JUC 进程和线程： 进程：一个进程可以包含多个线程，至少是一个线程，java默认2个线程——main、GC（垃圾回收） 线程：开了一个软件，写字的时候也会有自动保存的线程在进行，Thread、Runnable、Callable java开启不了线程，java操作的是底层的C++，java无法操作，用的是虚拟机 并发与并行： 并发：多线程操作同一个资源（假设cpu只有一核的时候，模拟多线程，快速交替处理线程） 并行：CPU多核情况下才有，多个线程同时执行 并发编程的本质：充分利用电脑的CPU 线程有几种
java juc_JUC
weixin_39934085的博客
02-12 148
前言：在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。下面一起来看看它怎么使用。欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。一、volatile关键字与内存可...
1、什么是juc
qq_45541846的博客
08-24 2389
什么是juc
Java并发编程（JUC）
weixin_43872993的博客
04-19 3732
1、Java并发编程——线程之间高效协作 2、了解JUC基本原理，了解各种锁的机制，避免死锁
JAVA中J.U.C 包下并发类的应用
雨田说码
07-08 1188
JUC包中的锁应用 Lock接口及ReentrantLock对象分析及应用？ 并发编程领域，有两大核心问题：一个是互斥，即同一时刻只允许一个线程访问共享资源；另一个是同步，即线程之间如何通信、协作。这两大问题，在Java SDK 并发包可通过 Lock 和 Condition 两个接口来实现，其中Lock 用于解决互斥问题，Condition 用于解决同步问题。Java SDK 并发包里的 Lock 接口中，不仅有支持类似 synchronized 的隐式加锁方法，还支持超时、非阻塞、可中断的方式获取锁，
Java JUC并发编程详解
靖节先生的博客
12-20 527
Java JUC并发编程详解1. JUC概述1.1 JUC简介1.2 进程与线程1.2 并发与并行1.3 用户线程和守护线程2. Lock接口2.1 Synchronized2.2 什么是 Lock2.3 ReentrantLock2.4 ReadWriteLock2.5 Lock与Synchronized区别3. 线程间通信3.1 synchronized方案3.2 lock方案3.4 线程间定制化通信4. 集合线程安全4.1 ArrayList线程不安全4.2 Vector线程安全4.3 Collect
java并发编程JUC补充学习：JUC包常用类
Kiwi_fruit的博客
07-23 3328
java并发编程JUC补充学习：JUC包常用类，包括atomic包、locks包、同步工具类、并发容器类、Executor框架相关类等。
java juc面试
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。...通过使用Java JUC，开发人员可以更方便地实现并发编程，提高系统的性能和可伸缩性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值