JUC Day03 (阻塞队列、JAVA1.8特性、Stream流式编程、异步回调)

最新推荐文章于 2024-02-03 20:19:42 发布
最新推荐文章于 2024-02-03 20:19:42 发布
阅读量184 收藏
点赞数
分类专栏： 面试经验总结 知识回顾 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49610478/article/details/112612384
版权

7.Callable(简单)

在这里插入图片描述
1、Callable 能够返回结果
2、能够报异常
3、方法与Runable 和Thread不同

代码：

package Callable;

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

/**
 * @Description:
 * @Author Bowen
 * @Date 2021/1/14 15:28
 **/
public class DemoCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        new Thread().start();//怎么启动Callable
//        new Thread(new FutureTask<V>()).start();
//        new Thread(new FutureTask<V>(callable)).start();
// 因为想要实现调用callable就要实现runnable ,那么FutureTask就是Runnable的实现类
// 并且FutureTask的构造器方法中能够接收callable参数，所以即可完成调用
        new Thread().start();

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); //只打印一次Call()，因为有缓存
        // 获取返回值，【可能会发生阻塞】：建议放在最后一行或者异步通信
        Integer o = (Integer) futureTask.get(); 
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

细节：
1、有缓存
2、可能会发生阻塞

8、常用的辅助类

8.1 CountDownLatch（重点）（减法计数器）

在这里插入图片描述
代码：

package SecUtils;

import java.util.concurrent.CountDownLatch;

/**
 * @Description:
 * @Author Bowen
 * @Date 2021/1/14 16:37
 **/
public class DemoCountDownLunch {
    public static void main(String[] args) throws InterruptedException {
        // 倒计时 总数为6
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i < 6 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"go Out");
                countDownLatch.countDown();//计数器 -1  Bowen
            },String.valueOf(i)).start();

        }
        countDownLatch.await();//等计数器归零才继续往下走;
        System.out.println("close Door");
    }
}
/**
结果为：
0go Out
2go Out
4go Out
3go Out
1go Out
5go Out
close Door 
**/

方法：
0：初始化的时候规定初始数
1：countDown() 计数器-1
2：await() 当归零再向下执行

8.2 CyclicBarrier（加法计数器）

在这里插入图片描述
代码：

package SecUtils;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @Description:
 * @Author Bowen
 * @Date 2021/1/14 16:44
 **/
public class DemoCyclicBarrier {
    public static void main(String[] args) {
        //  集齐个数

        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐7个");
        });

        for (int i = 0; i < 7 ; i++) {
//            lamda表达式能够操作到i嘛 实际上是不能的
//            解决方法：将循环中的i赋值给一个final int 变量即可 不写final在1.8jvm中也会默认加上
            int temp = i;
            new Thread(()->{
                try {
                    System.out.println("第"+temp+"个");
                    cyclicBarrier.await();//    await0为共计有7个线程时，完成cyclicBarrier初始化中的lamda方法，并且阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },i+"").start();
        }
    }
}

/**
结果：
第0个
第2个
第3个
第4个
第6个
第1个
第5个
集齐7个

**/

8.3 Semaphore（信号量，限流）

在这里插入图片描述

代码:

package SecUtils;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author Bowen
 * @Date 2021/1/15 8:39
 **/
public class DemoSemaphore {
    public static void main(String[] args) {
//        线程数量，限流
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"进入位置");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开位置");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },i+"").start();
        }
    }
}
/**
结果：
 0进入位置
2进入位置
1进入位置
0离开位置
1离开位置
2离开位置
4进入位置
5进入位置
3进入位置
5离开位置
3离开位置
4离开位置
**/

原理：
Semaphore semaphore = new Semaphore(3); 初始化限制数
semaphore.acquire();记录线程数，如果达到上限，等待，等待释放为止
semaphore.release();释放线程数
作用：
多个共享资源互斥的使用！并发限流，控制最大的线程数。

9、读写锁

在这里插入图片描述
代码：

package lock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 独占锁（写锁）只能一个线程占有
 共享锁（读锁）多个线程可以同时占有
 ReadWriteLock
 读-读    可以共存
 读-写    不能共存
 写-写    不能共存
 **/
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

//        存，
        for (int i = 0; i < 100; i++) {
            int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+":value");
            },i+"").start();
        }

//        读取
        for (int i = 0; i < 100; i++) {
            int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },i+"").start();
        }
    }
}

class MyCache{

    private volatile Map<String, Object> map = new HashMap<>();
    //        读写锁，更加细粒度的操作
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //    存、写 写入的时候，只希望同时只有一个线程写入
    public void put(String key, Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入…"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入完成"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

//    取、读 所有人都去读
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取…"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

阻塞队列

阻塞：

  • 写入：如果队列满了，就必须阻塞
  • 读取：如果队列是空的，必须阻塞，等待生产写入

队列：

  • FIFO （First In Frist Out 模式）先进先出
    在这里插入图片描述
    什么情况下会使用阻塞队列：
    多线程并发、线程池
    在这里插入图片描述

学会使用队列：
添加、移除

四组API

方式抛出异常有返回值，不抛出异常阻塞等待超时等待
添加addoffer()put()重写offer(字段,值,TimeUnit单位)
移除removepoll()take()重写poll(值,TimeUnit单位)
判断队列首elementpeek

1、抛出异常

 public static void test(){
//        初始化时要定义大小
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
//        IllegalStateException:Queue full 抛出异常！ 队列满了无法添加
        System.out.println(blockingQueue.add("d"));


        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
//        NoSuchElementException:队列中没有元素的 抛出异常！ 队列空了无法删除
        System.out.println(blockingQueue.remove());
    }

2、不会抛出异常

  public static void test02(){
//        初始化时要定义大小
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
//        与add方法不同，这个错误只会返回false不会报错
        System.out.println(blockingQueue.offer("d"));

        System.out.println(blockingQueue.poll());
//        System.out.println(blockingQueue.remove());
    }

3、阻塞等待

    public static void test03() throws InterruptedException {
//        初始化
        ArrayBlockingQueue<Object> bq = new ArrayBlockingQueue<>(3);

        //等待、阻塞
        bq.put("1");
        bq.put("2");
        bq.put("3");
        //添加进不去之后就会一直阻塞等待
        bq.put("4");
        System.out.println(bq.take());

    }

4、超时不等待

    public static void test04() throws InterruptedException {

        ArrayBlockingQueue<Object> bq = new ArrayBlockingQueue<>(2);

        //超时不等待为重写offer/poll的方法
        bq.offer("a",3, TimeUnit.SECONDS);
        bq.offer("b",4,TimeUnit.SECONDS);
    		//如果添加失败 4秒后就放弃
        bq.offer("b",4,TimeUnit.SECONDS);

        bq.poll(2,TimeUnit.SECONDS);
    }

SychronizedQueue

可以理解为一种特殊的阻塞队列，只能存储一个元素
put后需要take取出来之后才能继续put

11、线程池（重点）

三大方法，7大参数，4种拒绝策略

池化技术

程序运行的本质=》占用系统资源！应对=》优化资源的使用=》池化技术

例如：线程池、连接池、内存池、对象池
池化技术：实现配置准备好，有人用就在这里取，不会反复实例、销毁

线程池的好处：
1、降低资源的消耗
2、提高响应的速度
3、方便管理
线程复用 限制并发数 管理线程

三大方法

//使用线程池创建
public class Demo01 {
    public static void main(String[] args) {
        ExecutorService threadPool01 = Executors.newSingleThreadExecutor();//单个线程
        ExecutorService threadPool02 = Executors.newFixedThreadPool(5);//创造一个固定的线程池大小

        ExecutorService threadPool03 = Executors.newCachedThreadPool();//可伸缩的，根据情况改变大小


        // 线程池用完，在程序结束前需要关闭线程池 Bowen
        try {
            for (int i = 0; i < 10; i++) {
                threadPool03.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"->OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool03.shutdown();
        }
//          threadPool01
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK
//        pool-1-thread-1OK

//        threadPool02
//        pool-1-thread-1->OK
//        pool-1-thread-2->OK
//        pool-1-thread-4->OK
//        pool-1-thread-3->OK
//        pool-1-thread-3->OK
//        pool-1-thread-5->OK
//        pool-1-thread-1->OK
//        pool-1-thread-1->OK
//        pool-1-thread-1->OK
//        pool-1-thread-1->OK
        
//        threadPool03
//        pool-2-thread-1->OK
//        pool-2-thread-2->OK
//        pool-2-thread-3->OK
//        pool-2-thread-1->OK
//        pool-2-thread-1->OK
//        pool-2-thread-3->OK
//        pool-2-thread-4->OK
//        pool-2-thread-2->OK
//        pool-2-thread-6->OK
//        pool-2-thread-5->OK

7大参数

// 本质ThreadPollExecutor

int corePoolSize,//核心线程池大小
int maxmumPoolSize // 最大核心线程池大小
long keepAliveTime // 超时了没有人调用会释放的线程数
TimeUnit unit,//超时单位
BlockingQueue<Runable> workQueue//阻塞队列
ThreadFactory threadFacotry //线程工厂，创建线程的，一般不会用
RejectedExecutionHandler handler // 拒绝策略

手动创建线程池

 //最大线程数如何定义配置
 //  1、CPU密集型 几核就 定义为几，可以保证CPU的效率最高 Runtime.getRuntime().avaliableProcessors();
 //  2、IO密集型 判断程序中是否耗IO的线程，取两倍即可
 //      程序中 15个大型任务 io是否占用资源！
        
 ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                2, //核心线程数2个，阻塞队列没满就一直是这两个线程在跑，阻塞队列满了就创建线程
                5,//最大线程数为5，超过5个线程根据拒绝策略进行拒绝，最多只能创建5个线程
                3,// 3秒超时自动删除核心线程外的线程
                TimeUnit.SECONDS,//超时的时间单位
                new LinkedBlockingDeque<>(4),//阻塞队列4可以最多容纳4个任务等待线程
                Executors.defaultThreadFactory(),//默认线程创建工厂
                new ThreadPoolExecutor.AbortPolicy());//队列满了，还有人进来就会不处理这个人，报异常
                
                //由线程池创建线程方法：
                poolExecutor.execute(()->{
                	
				})

4种拒绝策略


// 1 队列满了，还有任务进来就会不处理这个任务，报异常
new ThreadPoolExecutor.AbortPolicy()//

java.util.concurrent.RejectedExecutionException: Task poll.Demo02$$Lambda$1/990368553@7cca494b rejected from java.util.concurrent.ThreadPoolExecutor@7ba4f24f[Running, pool size = 5, active threads = 5, queued tasks = 4, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	at poll.Demo02.main(Demo02.java:23)

// 2 哪里来的请求，由来源方处理，例如main的任务，就由main自己完成
 new ThreadPoolExecutor.CallerRunsPolicy());
 
main->OK
main->OK
pool-1-thread-4->OK
pool-1-thread-4->OK
pool-1-thread-4->OK

//3 丢弃任务，不会抛出异常

new ThreadPoolExecutor.DiscardPolicy());//丢弃任务，不会抛出异常

// 4 丢弃阻塞队列中的任务，不会抛出异常

new ThreadPoolExecutor.DiscardOldestPolicy());

12、四大函数式接口（必须掌握）

新时代程序员，需要掌握1.8

  • lamda表达式
  • 链式编程
  • 函数式接口
  • Stream流式计算

函数式接口： Function 【输入一个值，处理后返回一个结果值】

 Function function = str-> str;

        System.out.println(function.apply("xxx"));

断定型接口： Predicate 【输入一个值，根据方法返回boolean类型】

   Predicate<String> predicate = str ->{return str.isEmpty();};

        System.out.println(predicate.test("str"));

消费型接口： Consumer 【只有参数，没有return】

Consumer consume = str -> System.out.println(str);

供给型接口： Supplier【只有返回值，没有参数】

Supplier supplier = () -> {return 1024;};

Stream流式计算

大数据：存储+计算
存储：MySQL 本质就是存储东西的;
计算都是应该交给流来操作的
在这里插入图片描述

package Stream;

import java.util.Arrays;
import java.util.List;

/**
 * 流式计算
 **/
public class Demo01 {
    public static void main(String[] args) {
        User u1 =new User(1,"a",21);
        User u2 =new User(2,"b",22);
        User u3 =new User(3,"c",23);
        User u4 =new User(4,"d",24);
        User u5 =new User(6,"e",26);
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

        //  链式编程
        list.stream()
                .filter(u->{ return u.getId()%2==0 ;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu2,uu1)->{return uu2.compareTo(uu1);})
                .forEach(System.out::println);

    }
}

class User{

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public User() {
    }

    public User(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    private Integer id;

    private String name;

    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

Forkjoin

什么是Forkjoin

Forkjoin是1.7开始的，并行执行任务，提高效率！
大数据：Map Reduce(把大任务拆分为小任务再把小任务结果 汇总 return)

特点： 工作窃取
不让线程等待：例如AB两个线程，B先执行完任务，会把A未执行的任务偷走执行，顺序为双端队列的另一边
在这里插入图片描述

在这里插入图片描述
Demo类 需要继承RecursiveTask并重写compute方法

package Forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 通过ForkjoinPool 通过它来执行
 forkjoinPool.execute(ForkjoinTask<?> task);
 forkjoinTask
 **/
public class Demo01 extends RecursiveTask<Long> {

        private Long start;
        private Long end;

        private Long temp = 10000L;

    public Demo01(Long start, Long end) {
        this.start = start;
        this.end = end;
    }


    @Override
    protected Long compute() {
        if((end-start)<temp){
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else{
            //  forkjoin 递归
            long middle = (start + end) / 2;//中间值
            Demo01 task1 = new Demo01(start, middle);
            task1.fork();
            Demo01 task2 = new Demo01(middle, end);
            task2.fork();
            return task1.join() + task2.join();
        }
    }
}

测试类

package Forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

/**

 **/
public class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();
    }

    // 1 Bowen
    public static void test1(){
        long sum = 0L;
        long startTime = System.currentTimeMillis();
        for (long i = 0; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println(sum + ":" + (endTime-startTime));
    }

    public static void test2() throws ExecutionException, InterruptedException {
        long startTime =System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask task = new Demo01(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();

        long endTime = System.currentTimeMillis();
        System.out.println(sum + ":" + (endTime-startTime));
    }

    public static void test3(){
        long sum = 0L;
        long startTime = System.currentTimeMillis();
        sum = LongStream.rangeClosed(0,10_0000_0000L).parallel().reduce(0,Long::sum);
        long endTime = System.currentTimeMillis();
        System.out.println(sum + ":" + (endTime-startTime));

    }
}

15、异步回调

Future 设计的初衷是对将来的某个事件的结果进行建模

package Futrure;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

//异步执行
//成功回调
//失败回调
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的runAsync 异步回调
        CompletableFuture<Void> objectCompletableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "runAsync => Void");
        });
        System.out.println("1111");
        objectCompletableFuture.get();//获取阻塞执行结果
        /*1111
        ForkJoinPool.commonPool-worker-1runAsync => Void*/
        
//        有返回值的 supplyAsync 异步回调
        CompletableFuture<Integer> uCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "supplyAsync=>Integer");
            return 1024;
        });
        
//        可以理解为，上面的是异步请求的方法体，下面为ajax的success:function(){}和error:function(){}
        uCompletableFuture.whenComplete((t,u)->{
            System.out.println(t);//正常的返回结果
            System.out.println(u);//报错的错误信息
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;//可以获取到错误的返回结果
        });

    }
}
老秃爵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java之异步回调
擀面皮
09-02 3545
异步回调我的理解： 1.使用了委托模式，调用方（ServiceA）持有被调用方（ServiceB）的引用，然后调用被调用方（ServiceB）的方法，被调用方方法（ServiceB）完成后，调用调用方（ServiceA）的回调函数做一些事情 2.异步回调多是一些耗时的操作，在新线程中去调用被调用方（ServiceB）方法 3.异步回调可以大大提高IO效率，这是当前开发的主流，比如Netty、...
详解ReentrantLock之Condition原理
Daniel的博客
01-20 9905
Condition Jdk中独占锁的实现除了使用关键字synchronized外,还可以使用ReentrantLock。虽然在性能上ReentrantLock和synchr...
【JUC系列】ReentrantLock的Condition实现原理
秋装什么的博客
01-27 88
【JUC系列】ReentrantLock的Condition实现原理
Java 异步回调
jmqxnxg的博客
07-16 832
回调函数是一个函数对象，可以在异步方法执行完毕后被调用，以便处理异步方法的执行结果。在上面的代码中，定义了一个`sendHttpRequest()`方法，该方法用于异步执行网络请求，并将`RequestCallback`对象作为参数传递给异步方法。在使用异步方法时，可以将`RequestCallback`对象作为参数传递给异步方法，以便在异步方法执行完毕后调用相应的回调方法。使用回调接口可以方便地处理异步方法的执行结果，并且可以将异步方法的执行和结果处理分离开来，使代码更加清晰和易于维护。
Java实现异步回调
-
02-03 1584
设想一个情景，A是处理业务的一个步骤，A需要解决一个问题，这时候A可以问B，让B来告诉A答案，这期间，A可以继续做自己的事情，而不用因为B做的事而阻塞。 于是，我们想到给B设置一个线程，让B去处理耗时的操作，然后处理完之后把结果告诉A。所以这个问题的要点就在于B处理完之后如何把结果告诉A。
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
最新发布
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
java并发编程：juc线程池
08-09
Java并发编程中的JUC线程池是Java程序员必须掌握的关键技术之一，它允许开发者高效地管理并发执行的任务，充分利用多核处理器的性能。线程池的出现解决了在并发环境中线程创建、销毁带来的开销，提高了系统资源的...
Java并发编程JUC知识点梳理总结
06-01
JUC并发编程知识点梳理思维导图
java并发编程专题（六）----浅析（JUC）Semaphore
08-18
Java 并发编程专题（六）----浅析（JUC）Semaphore Java 并发编程专题（六）----浅析（JUC）Semaphore 是 Java 并发编程中的一种重要机制，它主要用于控制多个线程访问共享资源的同时性。Semaphore 是一种信号量...
java并发编程专题（九）----（JUC）浅析CyclicBarrier
08-18
Java 并发编程专题（九）----（JUC）浅析 CyclicBarrier CyclicBarrier 是 Java 并发编程中的一个同步辅助工具，它允许一组线程全部等待彼此到达公共屏障点。它的字面意思是可循环使用的屏障，用于让一组线程到达一...
Java按时间梯度实现异步回调接口的方法
08-27
主要介绍了Java按时间梯度实现异步回调接口,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
Java 异步回调机制：实例解析
DevNinja的博客
10-03 393
在Java编程中，异步回调机制是一种常见的编程模式，它允许我们在进行异步操作时，通过回调函数来处理操作完成后的结果。假设我们有一个需求，需要通过网络请求获取一篇文章的内容，并在获取完成后进行相应的处理。我们使用Java的HttpURLConnection类来发起网络请求，并通过异步回调机制来处理请求完成后的结果。通过定义回调接口和实现回调方法，我们可以在异步操作完成后及时处理结果，从而提高程序的性能和响应性。"，然后在请求完成后打印出相应的结果或错误信息，具体取决于网络请求的结果。当请求失败时，将调用。
ReentrantLock底层原理、手写Lock锁
叶新东老师的博客
05-04 2863
ReentrantLock锁是一个轻量级锁，他的底层是由jdk实现的，和synchronized不同的是，synchronized在jdk1.5以前是一把很重的锁，每次使用时都需要向操作系统申请，所以会耗费很大的资源，且效率不高，但ReentrantLock 的底层是由cas实现的，cas本身是自旋锁，也叫无锁，因为轻量级锁不需要像操作系统申请锁资源，所以不会进入阻塞状态，所以lock锁的效率要比synchronized高很多； 我们先看看lock锁的底层原理流程图 知道了这些...
java并发锁机制----ReentrantLock 原理解析之Condition实现原理
tyrroo的博客
06-28 1504
1、java.util.concurrent.locks.Condition接口一览： void await() throws InterruptedException; void awaitUninterruptibly(); long awaitNanos(long nanosTimeout) throws InterruptedException; boolean await(lo...
JDK1.8源码分析：可重入锁ReentrantLock和Condition的实现原理
源码之下，了无秘密
02-14 6473
synchronized的用法和实现原理 synchronized实现线程同步的用法和实现原理 不足 synchronized在线程同步的使用方面，优点是使用简单，可以自动加锁和解锁，但是也存在一些不足： synchronized是阻塞的，不支持非阻塞，中断和超时退出特性； synchronized是互斥锁，不支持多个线程对资源的共享访问，如多个读线程进行并发读； 当多个方法共享多个mo...
Java多线程（九）之ReentrantLock与Condition
爱.NET
12-12 552
一、ReentrantLock 类 1.1 什么是reentrantlock java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock 类实现了 Lock ，它拥有与 ...
Java技术——ReentrantLock的Condition的作用以及使用
热门推荐
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
06-30 1万+
0. 前言 之前知道ReentrantLock类有一个newCondition()，用于获取Lock上的一个条件，还可以多次newCondition()获得多个条件，Condition可用于线程间通信。是对比ReentrantLock和Synchronized关键字的区别时学习到的。但是有次面试被问到有没有用到过ReentrantLock的Condition，瞬间懵逼了。所以搜集了些资...
java异步回调模式
xiaobinfeng的专栏
05-16 2981
java的异步回调模式，是指当类A实现了CallBack接口，Ａ类包含了B类的引用，在A类中调用B类的方法，然后在B类的方法中调用A类的callback方法。异步体现在：A类通过新起一个线程执行B类的方法，至于该方法有没有执行完，暂时不用去等待。下面是一个回调代码示例：类A实现了一个CallBack接口，来计算一个数的平方，在A类中调用B类的方法来计算，B通过回调返回计算结果。package ca...
ReentrantLock和Condition源码解析
m0_51141627的博客
09-30 226
Java除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。这篇文章主要是从源码的角度来分析一下ReentrantLock。 ReentrantLock 一、加锁 代码如下： ReentrantLock reentrantLock = new ReentrantLock(); reentrantLock.lock().
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值